1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Serialize query criteria

    15 *

    16 */

    17 

    18 

    19 #include "mdequerycriteriaserialization.h"

    20 #include "mdelogiccondition.h"

    21 #include "mdepropertydef.h"

    22 #include "mdenamespacedef.h"

    23 #include "mdeobjectdef.h"

    24 #include "mdcquery.h"

    25 #include "mdcserializationbuffer.h"

    26 

    27 

    28 CMdEQueryCriteriaSerialization* CMdEQueryCriteriaSerialization::NewL(

    29 	TQueryResultMode aResultMode, TQueryType aQueryType, 

    30 	CMdENamespaceDef& aNamespaceDef, 

    31 	CMdEObjectDef* aObjectDef, RPointerArray<CMdEObjectDef>* aObjectDefs, 

    32 	TUint32 aLimit, TUint32 aOffset, TUint32 aQueryOptimizationFlags,

    33 	CMdELogicCondition& aRootCondition, RArray<TMdEOrderRule>& aOrderRule, 

    34 	RPointerArray<CMdEPropertyDef>* aPropertyFilter)

    35 	{

    36     CMdEQueryCriteriaSerialization* serialization = 

    37     	CMdEQueryCriteriaSerialization::NewLC( aResultMode, aQueryType,

    38     										   aNamespaceDef, aObjectDef, aObjectDefs, 

    39     										   aLimit, aOffset, aQueryOptimizationFlags,

    40     										   aRootCondition, aOrderRule,

    41     										   aPropertyFilter );

    42     CleanupStack::Pop( serialization );

    43     return serialization;

    44     }

    45 

    46 CMdEQueryCriteriaSerialization* CMdEQueryCriteriaSerialization::NewLC(

    47 	TQueryResultMode aResultMode, TQueryType aQueryType, 

    48 	CMdENamespaceDef& aNamespaceDef, 

    49 	CMdEObjectDef* aObjectDef, RPointerArray<CMdEObjectDef>* aObjectDefs, 

    50 	TUint32 aLimit, TUint32 aOffset, TUint32 aQueryOptimizationFlags, 

    51 	CMdELogicCondition& aRootCondition, RArray<TMdEOrderRule>& aOrderRule, 

    52 	RPointerArray<CMdEPropertyDef>* aPropertyFilter)

    53 	{

    54     CMdEQueryCriteriaSerialization* serialization = 

    55     	new( ELeave ) CMdEQueryCriteriaSerialization( ETrue ); // Owns serialized buffer

    56     CleanupStack::PushL( serialization );

    57     serialization->ConstructL( aResultMode, aQueryType,

    58     						   aNamespaceDef, aObjectDef, aObjectDefs, 

    59     						   aLimit, aOffset, aQueryOptimizationFlags,

    60     						   aRootCondition, aOrderRule,

    61     						   aPropertyFilter );

    62     return serialization;

    63 	}

    64 

    65 CMdEQueryCriteriaSerialization* CMdEQueryCriteriaSerialization::NewL(

    66 	CMdCSerializationBuffer& aSerializationBuffer)

    67 	{

    68     CMdEQueryCriteriaSerialization* serialization = 

    69     	CMdEQueryCriteriaSerialization::NewLC( aSerializationBuffer );

    70     CleanupStack::Pop( serialization );

    71     return serialization;

    72 	}

    73 

    74 CMdEQueryCriteriaSerialization* CMdEQueryCriteriaSerialization::NewLC(

    75 	CMdCSerializationBuffer& aSerializationBuffer)

    76 	{

    77     CMdEQueryCriteriaSerialization* serialization = 

    78     	new( ELeave ) CMdEQueryCriteriaSerialization( EFalse ); // Doesn't own serialized buffer

    79     CleanupStack::PushL( serialization );

    80     serialization->iSerializedBuffer = &aSerializationBuffer;

    81     return serialization;

    82 	}

    83 

    84 CMdEQueryCriteriaSerialization::~CMdEQueryCriteriaSerialization()

    85 	{

    86 	if( iOwnSerializedBuffer )

    87 		{

    88 		delete iSerializedBuffer;

    89 		}

    90 	}

    91 	

    92 TPtr8 CMdEQueryCriteriaSerialization::Buffer() const

    93 	{

    94 	return iSerializedBuffer->Buffer();

    95 	}

    96 

    97 const TPtr8* CMdEQueryCriteriaSerialization::BufferPtr() const

    98 	{

    99 	return iSerializedBuffer->BufferPtr();

   100 	}

   101 

   102 CMdCSerializationBuffer& CMdEQueryCriteriaSerialization::SerializationBuffer()

   103 	{

   104 	return *iSerializedBuffer;

   105 	}

   106 

   107 CMdEQueryCriteriaSerialization::CMdEQueryCriteriaSerialization(TBool aOwnSerializedBuffer)

   108 	: iSerializedBuffer( NULL ), iOwnSerializedBuffer( aOwnSerializedBuffer )

   109 	{

   110 	

   111 	}

   112 

   113 void CMdEQueryCriteriaSerialization::ConstructL(

   114 	TQueryResultMode aResultMode, TQueryType aQueryType, 

   115 	CMdENamespaceDef& aNamespaceDef, 

   116 	CMdEObjectDef* aObjectDef, RPointerArray<CMdEObjectDef>* aObjectDefs, 

   117 	TUint32 aLimit, TUint32 aOffset, TUint32 aQueryOptimizationFlags, 

   118 	CMdELogicCondition& aRootCondition, RArray<TMdEOrderRule>& aOrderRules, 

   119 	RPointerArray<CMdEPropertyDef>* aPropertyFilter)

   120 	{

   121 	// If aResultMode is EModeDistinctValues aQueryType must be CMdEQuery::ETypeObject

   122 	if( EQueryResultModeDistinctValues == aResultMode )

   123 		{

   124 		if( EQueryTypeObject != aQueryType )

   125 			{

   126 			User::Leave( KErrNotSupported );

   127 			}

   128 		else

   129 			{

   130 			// Order rules might also contain one order rule and it must be 

   131 			// same as defined in propery condition.

   132 			if( aOrderRules.Count() > 1 )

   133 				{

   134 				User::Leave( KErrCompletion );

   135 				}

   136 

   137 			// One property filter must exist and it must be same as property condition

   138 			if( aPropertyFilter )

   139 				{

   140 				if( aPropertyFilter->Count() != 1 )

   141 					{

   142 					User::Leave( KErrCompletion );

   143 					}

   144 				}

   145 			else

   146 				{

   147 				User::Leave( KErrCompletion);

   148 				}

   149 			}

   150 		}

   151 	

   152 	TUint32 criteriaBufferSize = sizeof( TMdCSearchCriteria );

   153 	

   154 	// Required size for object defs IDs

   155 	TUint32 objectDefIdCount = 0;

   156 	if( aObjectDefs )

   157 		{

   158 		objectDefIdCount = aObjectDefs->Count();

   159 

   160 		criteriaBufferSize += objectDefIdCount * 

   161 				CMdCSerializationBuffer::KRequiredSizeForTDefId;

   162 		}

   163 

   164 	// Required size for conditions

   165 	criteriaBufferSize += aRootCondition.RequiredBufferSize();

   166 

   167 	// Required size for order rule offsets

   168 	const TInt orderRuleCount = aOrderRules.Count();

   169 	criteriaBufferSize += orderRuleCount * 

   170 			CMdCSerializationBuffer::KRequiredSizeForTUint32;

   171 

   172 	// Required size for order rules

   173 	for( TInt i = 0; i < orderRuleCount; i++ )

   174 		{

   175 		criteriaBufferSize += aOrderRules[i].RequiredBufferSize();

   176 		}

   177 

   178 	// Required size for property filters

   179 	TUint32 propertyFilterCount = 0;

   180 	if( aPropertyFilter )

   181 		{

   182 		propertyFilterCount = aPropertyFilter->Count();

   183 		

   184 		criteriaBufferSize += propertyFilterCount * 

   185 			CMdCSerializationBuffer::KRequiredSizeForTDefId;

   186 		}

   187 

   188 	// Reserve buffer

   189 	iSerializedBuffer = CMdCSerializationBuffer::NewL( criteriaBufferSize );

   190 

   191 	// Insert data to search criteria

   192 

   193 	TMdCSearchCriteria criteria;

   194 	criteria.iQueryResultType = aResultMode;

   195 	criteria.iQueryType = aQueryType;

   196 	criteria.iNamespaceDefId = aNamespaceDef.Id();

   197 

   198 	if( aObjectDef )

   199 		{

   200 		criteria.iObjectDefId = aObjectDef->Id();

   201 		}

   202 	else

   203 		{

   204 		criteria.iObjectDefId = KNoDefId;

   205 		}

   206 

   207 	criteria.iObjectDefIds.iPtr.iCount = objectDefIdCount;

   208 	// init offset to "zero", will be updated later if needed

   209 	criteria.iObjectDefIds.iPtr.iOffset = KNoOffset;

   210 

   211 	criteria.iLimit = aLimit;

   212 	criteria.iOffset = aOffset;

   213 	criteria.iOptimizationFlags = aQueryOptimizationFlags;

   214 

   215 	// init offset to "zero", will be updated later

   216 	criteria.iRootCondition = KNoOffset;

   217 

   218 	criteria.iOrderRules.iPtr.iCount = orderRuleCount;

   219 	// init offset to "zero", will be updated later if needed

   220 	criteria.iOrderRules.iPtr.iOffset = KNoOffset;

   221 

   222 	criteria.iPropertyFilters.iPtr.iCount = propertyFilterCount;

   223 	// init offset to "zero", will be updated later if needed

   224 	criteria.iPropertyFilters.iPtr.iOffset = KNoOffset;

   225 

   226 	// Insert data to serialized buffer

   227 

   228 	// Position after search criteria

   229 	const TUint32 afterCriteriaOffset = sizeof( TMdCSearchCriteria );

   230 

   231 	// Move to position after search criteria

   232 	iSerializedBuffer->PositionL( afterCriteriaOffset );

   233 

   234 	if( aObjectDefs )

   235 		{

   236 		// Update object defs offset to search criteria

   237 		criteria.iObjectDefIds.iPtr.iOffset = afterCriteriaOffset;

   238 

   239 		// Update object defs count

   240 		for( TUint32 i = 0; i < objectDefIdCount; i++ )

   241 			{

   242 			TDefId defId = (*aObjectDefs)[i]->Id();

   243 			iSerializedBuffer->InsertL( defId );

   244 			}

   245 		}

   246 

   247 	// Update root condition offset to position after search criteria 

   248 	// (and possible object defs IDs)

   249 	criteria.iRootCondition = iSerializedBuffer->Position();

   250 

   251 	TUint32 offset = KNoOffset;

   252 	// Insert root condition to serialized buffer

   253 	aRootCondition.SerializeL( *iSerializedBuffer, offset );

   254 

   255 	// move position after conditions

   256 	iSerializedBuffer->PositionL( offset );

   257 	

   258 	if( orderRuleCount > 0 )

   259 		{

   260 		// Update order rule offset to position after search criteria 

   261 		// (and possible object defs IDs) and root condition

   262 		criteria.iOrderRules.iPtr.iOffset = iSerializedBuffer->Position();

   263 

   264 		for( TUint32 i = 0; i < orderRuleCount; i++)

   265 			{

   266 			// Insert current order rule

   267 			aOrderRules[i].SerializeL( *iSerializedBuffer, offset );

   268 			}

   269 		}

   270 

   271 	// move position after order rules

   272 	iSerializedBuffer->PositionL( offset );

   273 	

   274 	if( aPropertyFilter )

   275 		{

   276 		// Update order property filter offset to position after search 

   277 		// criteria (and possible object defs IDs), 

   278 		// root condition and order rules

   279 		criteria.iPropertyFilters.iPtr.iOffset = iSerializedBuffer->Position();

   280 

   281 		for( TUint32 i = 0; i < propertyFilterCount; i++ )

   282 			{

   283 			CMdEPropertyDef* propertyDef = (*aPropertyFilter)[i];

   284 			iSerializedBuffer->InsertL( propertyDef->Id() );

   285 			}

   286 		}

   287 

   288 	// move buffer to begin and serialize search criteria

   289 	iSerializedBuffer->PositionL( KNoOffset );

   290 	criteria.SerializeL( *iSerializedBuffer );

   291 	}