diff -r 000000000000 -r c53acadfccc6 metadataengine/client/src/mdequerycriteriaserialization.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/metadataengine/client/src/mdequerycriteriaserialization.cpp Mon Jan 18 20:34:07 2010 +0200 @@ -0,0 +1,291 @@ +/* +* 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: Serialize query criteria +* +*/ + + +#include "mdequerycriteriaserialization.h" +#include "mdelogiccondition.h" +#include "mdepropertydef.h" +#include "mdenamespacedef.h" +#include "mdeobjectdef.h" +#include "mdcquery.h" +#include "mdcserializationbuffer.h" + + +CMdEQueryCriteriaSerialization* CMdEQueryCriteriaSerialization::NewL( + TQueryResultMode aResultMode, TQueryType aQueryType, + CMdENamespaceDef& aNamespaceDef, + CMdEObjectDef* aObjectDef, RPointerArray* aObjectDefs, + TUint32 aLimit, TUint32 aOffset, TUint32 aQueryOptimizationFlags, + CMdELogicCondition& aRootCondition, RArray& aOrderRule, + RPointerArray* aPropertyFilter) + { + CMdEQueryCriteriaSerialization* serialization = + CMdEQueryCriteriaSerialization::NewLC( aResultMode, aQueryType, + aNamespaceDef, aObjectDef, aObjectDefs, + aLimit, aOffset, aQueryOptimizationFlags, + aRootCondition, aOrderRule, + aPropertyFilter ); + CleanupStack::Pop( serialization ); + return serialization; + } + +CMdEQueryCriteriaSerialization* CMdEQueryCriteriaSerialization::NewLC( + TQueryResultMode aResultMode, TQueryType aQueryType, + CMdENamespaceDef& aNamespaceDef, + CMdEObjectDef* aObjectDef, RPointerArray* aObjectDefs, + TUint32 aLimit, TUint32 aOffset, TUint32 aQueryOptimizationFlags, + CMdELogicCondition& aRootCondition, RArray& aOrderRule, + RPointerArray* aPropertyFilter) + { + CMdEQueryCriteriaSerialization* serialization = + new( ELeave ) CMdEQueryCriteriaSerialization( ETrue ); // Owns serialized buffer + CleanupStack::PushL( serialization ); + serialization->ConstructL( aResultMode, aQueryType, + aNamespaceDef, aObjectDef, aObjectDefs, + aLimit, aOffset, aQueryOptimizationFlags, + aRootCondition, aOrderRule, + aPropertyFilter ); + return serialization; + } + +CMdEQueryCriteriaSerialization* CMdEQueryCriteriaSerialization::NewL( + CMdCSerializationBuffer& aSerializationBuffer) + { + CMdEQueryCriteriaSerialization* serialization = + CMdEQueryCriteriaSerialization::NewLC( aSerializationBuffer ); + CleanupStack::Pop( serialization ); + return serialization; + } + +CMdEQueryCriteriaSerialization* CMdEQueryCriteriaSerialization::NewLC( + CMdCSerializationBuffer& aSerializationBuffer) + { + CMdEQueryCriteriaSerialization* serialization = + new( ELeave ) CMdEQueryCriteriaSerialization( EFalse ); // Doesn't own serialized buffer + CleanupStack::PushL( serialization ); + serialization->iSerializedBuffer = &aSerializationBuffer; + return serialization; + } + +CMdEQueryCriteriaSerialization::~CMdEQueryCriteriaSerialization() + { + if( iOwnSerializedBuffer ) + { + delete iSerializedBuffer; + } + } + +TPtr8 CMdEQueryCriteriaSerialization::Buffer() const + { + return iSerializedBuffer->Buffer(); + } + +const TPtr8* CMdEQueryCriteriaSerialization::BufferPtr() const + { + return iSerializedBuffer->BufferPtr(); + } + +CMdCSerializationBuffer& CMdEQueryCriteriaSerialization::SerializationBuffer() + { + return *iSerializedBuffer; + } + +CMdEQueryCriteriaSerialization::CMdEQueryCriteriaSerialization(TBool aOwnSerializedBuffer) + : iSerializedBuffer( NULL ), iOwnSerializedBuffer( aOwnSerializedBuffer ) + { + + } + +void CMdEQueryCriteriaSerialization::ConstructL( + TQueryResultMode aResultMode, TQueryType aQueryType, + CMdENamespaceDef& aNamespaceDef, + CMdEObjectDef* aObjectDef, RPointerArray* aObjectDefs, + TUint32 aLimit, TUint32 aOffset, TUint32 aQueryOptimizationFlags, + CMdELogicCondition& aRootCondition, RArray& aOrderRules, + RPointerArray* aPropertyFilter) + { + // If aResultMode is EModeDistinctValues aQueryType must be CMdEQuery::ETypeObject + if( EQueryResultModeDistinctValues == aResultMode ) + { + if( EQueryTypeObject != aQueryType ) + { + User::Leave( KErrNotSupported ); + } + else + { + // Order rules might also contain one order rule and it must be + // same as defined in propery condition. + if( aOrderRules.Count() > 1 ) + { + User::Leave( KErrCompletion ); + } + + // One property filter must exist and it must be same as property condition + if( aPropertyFilter ) + { + if( aPropertyFilter->Count() != 1 ) + { + User::Leave( KErrCompletion ); + } + } + else + { + User::Leave( KErrCompletion); + } + } + } + + TUint32 criteriaBufferSize = sizeof( TMdCSearchCriteria ); + + // Required size for object defs IDs + TUint32 objectDefIdCount = 0; + if( aObjectDefs ) + { + objectDefIdCount = aObjectDefs->Count(); + + criteriaBufferSize += objectDefIdCount * + CMdCSerializationBuffer::KRequiredSizeForTDefId; + } + + // Required size for conditions + criteriaBufferSize += aRootCondition.RequiredBufferSize(); + + // Required size for order rule offsets + const TInt orderRuleCount = aOrderRules.Count(); + criteriaBufferSize += orderRuleCount * + CMdCSerializationBuffer::KRequiredSizeForTUint32; + + // Required size for order rules + for( TInt i = 0; i < orderRuleCount; i++ ) + { + criteriaBufferSize += aOrderRules[i].RequiredBufferSize(); + } + + // Required size for property filters + TUint32 propertyFilterCount = 0; + if( aPropertyFilter ) + { + propertyFilterCount = aPropertyFilter->Count(); + + criteriaBufferSize += propertyFilterCount * + CMdCSerializationBuffer::KRequiredSizeForTDefId; + } + + // Reserve buffer + iSerializedBuffer = CMdCSerializationBuffer::NewL( criteriaBufferSize ); + + // Insert data to search criteria + + TMdCSearchCriteria criteria; + criteria.iQueryResultType = aResultMode; + criteria.iQueryType = aQueryType; + criteria.iNamespaceDefId = aNamespaceDef.Id(); + + if( aObjectDef ) + { + criteria.iObjectDefId = aObjectDef->Id(); + } + else + { + criteria.iObjectDefId = KNoDefId; + } + + criteria.iObjectDefIds.iPtr.iCount = objectDefIdCount; + // init offset to "zero", will be updated later if needed + criteria.iObjectDefIds.iPtr.iOffset = KNoOffset; + + criteria.iLimit = aLimit; + criteria.iOffset = aOffset; + criteria.iOptimizationFlags = aQueryOptimizationFlags; + + // init offset to "zero", will be updated later + criteria.iRootCondition = KNoOffset; + + criteria.iOrderRules.iPtr.iCount = orderRuleCount; + // init offset to "zero", will be updated later if needed + criteria.iOrderRules.iPtr.iOffset = KNoOffset; + + criteria.iPropertyFilters.iPtr.iCount = propertyFilterCount; + // init offset to "zero", will be updated later if needed + criteria.iPropertyFilters.iPtr.iOffset = KNoOffset; + + // Insert data to serialized buffer + + // Position after search criteria + const TUint32 afterCriteriaOffset = sizeof( TMdCSearchCriteria ); + + // Move to position after search criteria + iSerializedBuffer->PositionL( afterCriteriaOffset ); + + if( aObjectDefs ) + { + // Update object defs offset to search criteria + criteria.iObjectDefIds.iPtr.iOffset = afterCriteriaOffset; + + // Update object defs count + for( TUint32 i = 0; i < objectDefIdCount; i++ ) + { + TDefId defId = (*aObjectDefs)[i]->Id(); + iSerializedBuffer->InsertL( defId ); + } + } + + // Update root condition offset to position after search criteria + // (and possible object defs IDs) + criteria.iRootCondition = iSerializedBuffer->Position(); + + TUint32 offset = KNoOffset; + // Insert root condition to serialized buffer + aRootCondition.SerializeL( *iSerializedBuffer, offset ); + + // move position after conditions + iSerializedBuffer->PositionL( offset ); + + if( orderRuleCount > 0 ) + { + // Update order rule offset to position after search criteria + // (and possible object defs IDs) and root condition + criteria.iOrderRules.iPtr.iOffset = iSerializedBuffer->Position(); + + for( TUint32 i = 0; i < orderRuleCount; i++) + { + // Insert current order rule + aOrderRules[i].SerializeL( *iSerializedBuffer, offset ); + } + } + + // move position after order rules + iSerializedBuffer->PositionL( offset ); + + if( aPropertyFilter ) + { + // Update order property filter offset to position after search + // criteria (and possible object defs IDs), + // root condition and order rules + criteria.iPropertyFilters.iPtr.iOffset = iSerializedBuffer->Position(); + + for( TUint32 i = 0; i < propertyFilterCount; i++ ) + { + CMdEPropertyDef* propertyDef = (*aPropertyFilter)[i]; + iSerializedBuffer->InsertL( propertyDef->Id() ); + } + } + + // move buffer to begin and serialize search criteria + iSerializedBuffer->PositionL( KNoOffset ); + criteria.SerializeL( *iSerializedBuffer ); + }