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:  ?Description

    15 *

    16 */

    17 

    18 #include "mdeobjectcondition.h"

    19 #include "mdcserializationbuffer.h"

    20 #include "mdeobjectdef.h"

    21 #include "mdepanic.h"

    22 #include "mdscommoninternal.h"

    23 #include "mdcquery.h"

    24 

    25 

    26 CMdEObjectCondition* CMdEObjectCondition::NewL( TObjectConditionCompareMethod aCompareMethod,

    27 		TItemId aObjectId, const CMdEObjectDef* aObjectDef,

    28 		TInt64 aObjectGuidHigh, TInt64 aObjectGuidLow )

    29 	{

    30 	CMdEObjectCondition* self = CMdEObjectCondition::NewLC( aCompareMethod,

    31 			aObjectId, aObjectDef, aObjectGuidHigh, aObjectGuidLow );

    32 	CleanupStack::Pop( self );

    33 	return self;	

    34 	}

    35 

    36 CMdEObjectCondition* CMdEObjectCondition::NewLC( TObjectConditionCompareMethod aCompareMethod,

    37 		TItemId aObjectId, const CMdEObjectDef* aObjectDef,

    38 		TInt64 aObjectGuidHigh, TInt64 aObjectGuidLow )

    39 	{

    40 	CMdEObjectCondition* self = new (ELeave) CMdEObjectCondition( aCompareMethod,

    41 			aObjectId, aObjectDef, aObjectGuidHigh, aObjectGuidLow );

    42 	CleanupStack::PushL( self );

    43 	self->ConstructL();

    44 	return self;

    45 	}

    46 

    47 CMdEObjectCondition* CMdEObjectCondition::NewL( TObjectConditionCompareMethod aCompareMethod,

    48 		const RArray<TItemId>* aObjectIds, const TDesC* aString, const TMdEUintRange* aRange )

    49 	{

    50 	CMdEObjectCondition* self = CMdEObjectCondition::NewLC( aCompareMethod, aObjectIds, aString, aRange );

    51 	CleanupStack::Pop( self );

    52 	return self;	

    53 	}

    54 

    55 CMdEObjectCondition* CMdEObjectCondition::NewLC( TObjectConditionCompareMethod aCompareMethod,

    56 		const RArray<TItemId>* aObjectIds, const TDesC* aString, const TMdEUintRange* aRange )

    57 	{

    58 	CMdEObjectCondition* self = new (ELeave) CMdEObjectCondition( aCompareMethod );

    59 	CleanupStack::PushL( self );

    60 	self->ConstructL( aObjectIds, aString, aRange );

    61 	return self;

    62 	}

    63 

    64 

    65 CMdEObjectCondition::CMdEObjectCondition( TObjectConditionCompareMethod aCompareMethod,

    66 									TItemId aObjectId, const CMdEObjectDef* aObjectDef,

    67 									TInt64 aObjectGuidHigh, TInt64 aObjectGuidLow )

    68 	: CMdECondition(EConditionTypeObject), iObjectDef( aObjectDef ), 

    69 	  iObjectId( aObjectId ), iObjectIds( NULL ), 

    70 	  iString( NULL ), iCompareMethod( aCompareMethod ), iFlags( 0 ),

    71 	  iConfidentialityLevel(EObjectConditionLevelNormal),

    72 	  iGuidHigh( aObjectGuidHigh ), iGuidLow( aObjectGuidLow ),

    73 	  iRange( NULL )

    74 	{

    75 	#ifdef _DEBUG

    76 	if ( iObjectDef )

    77 		{

    78 		__ASSERT_DEBUG(aCompareMethod == EObjectConditionCompareObjectDef, TMdEPanic::Panic(TMdEPanic::EInternal));

    79 		}

    80 	else if ( iObjectId != KNoId )

    81 		{

    82 		__ASSERT_DEBUG(aCompareMethod == EObjectConditionCompareId, TMdEPanic::Panic(TMdEPanic::EInternal));

    83 		}

    84 	else if ( iGuidHigh != 0 || iGuidLow != 0 )

    85 		{

    86 		__ASSERT_DEBUG(aCompareMethod == EObjectConditionCompareGuid, TMdEPanic::Panic(TMdEPanic::EInternal));

    87 		}

    88 	else

    89 		{

    90 		__ASSERT_DEBUG(aCompareMethod == EObjectConditionCompareNone, TMdEPanic::Panic(TMdEPanic::EInternal));

    91 		}

    92 	

    93 	#endif

    94 	}

    95 

    96 CMdEObjectCondition::CMdEObjectCondition( TObjectConditionCompareMethod aCompareMethod )

    97 	: CMdECondition(EConditionTypeObject), iObjectDef( NULL ), 

    98 	  iObjectId( KNoId ), iObjectIds( NULL ), 

    99 	  iString( NULL ), iCompareMethod( aCompareMethod ), iFlags( 0 ),

   100 	  iConfidentialityLevel(EObjectConditionLevelNormal), iGuidHigh( 0 ), iGuidLow( 0 )

   101 	{

   102 	__ASSERT_DEBUG(iCompareMethod > EObjectConditionCompareFirst && iCompareMethod < EObjectConditionCompareLast, TMdEPanic::Panic(TMdEPanic::EInternal));

   103 	}

   104 

   105 void CMdEObjectCondition::ConstructL()

   106     {

   107     // Base class construction.

   108     ConditionConstruct();

   109     

   110     // Non-confidential objects are queried by default

   111     iConfidentialityLevel = EObjectConditionLevelNormal;

   112     }

   113 

   114 void CMdEObjectCondition::ConstructL( const RArray<TItemId>* aObjectIds,

   115 		const TDesC* aString, const TMdEUintRange* aRange )

   116 	{

   117 	if ( aString )

   118 		{

   119 		iString = HBufC::NewL(aString->Length());

   120 		iString->Des().CopyLC( *aString );

   121 		}

   122 	else if ( aObjectIds )

   123 		{

   124 	    iObjectIds = new (ELeave) RArray<TItemId>;

   125 		

   126 	    const TInt objectIdCount = aObjectIds->Count();

   127 	    iObjectIds->ReserveL( objectIdCount );

   128 	    

   129 		for( TInt i = 0; i < objectIdCount; i++ )

   130 			{

   131 			iObjectIds->Append( (*aObjectIds)[i] );

   132 			}

   133 		}

   134 	else if ( aRange )

   135 		{

   136 		iRange = new(ELeave) TMdEUintRange(*aRange);

   137 		}

   138 	else

   139 		{

   140 		User::Leave( KErrArgument );

   141 		}

   142 	}

   143 

   144 CMdEObjectCondition::~CMdEObjectCondition()

   145 	{

   146    	delete iString;

   147 

   148    	if( iObjectIds )

   149     	{

   150     	iObjectIds->Close();

   151     	

   152     	delete iObjectIds;

   153     	}

   154     

   155    	delete iRange;

   156 	}

   157 

   158 EXPORT_C const CMdEObjectDef* CMdEObjectCondition::ObjectDef() const

   159     {

   160     return iObjectDef;

   161     }

   162 

   163 EXPORT_C TItemId CMdEObjectCondition::ObjectId() const

   164     {

   165     return iObjectId;

   166     }

   167 

   168 EXPORT_C const RArray<TItemId>* CMdEObjectCondition::ObjectIds() const

   169 	{

   170 	return iObjectIds;

   171 	}

   172 

   173 EXPORT_C const TDesC* CMdEObjectCondition::String() const

   174     {

   175     return iString;

   176     }

   177 

   178 

   179 EXPORT_C TObjectConditionCompareMethod CMdEObjectCondition::CompareMethod() const

   180     {

   181     return iCompareMethod;

   182     }

   183 

   184 

   185 EXPORT_C TObjectConditionConfidentialityLevel CMdEObjectCondition::ConfidentialityLevel() const

   186     {

   187     return iConfidentialityLevel;

   188     }

   189 

   190 EXPORT_C void CMdEObjectCondition::SetConfidentialityLevel( TObjectConditionConfidentialityLevel aLevel )

   191     {

   192     iConfidentialityLevel = aLevel;

   193     }

   194 

   195 EXPORT_C TBool CMdEObjectCondition::NotPresent() const

   196 	{

   197 	return iFlags & EMdEObjectFlagNotPresent ? ETrue : EFalse;

   198 	}

   199 

   200 EXPORT_C void CMdEObjectCondition::SetNotPresent(TBool aNotPresent)

   201 	{

   202 	if( aNotPresent )

   203 		{

   204 		iFlags |= EMdEObjectFlagNotPresent; 

   205 		}

   206 	else

   207 		{

   208 		iFlags &= ~EMdEObjectFlagNotPresent;

   209 		}

   210 	}

   211 

   212 EXPORT_C TBool CMdEObjectCondition::NotPlaceholder() const

   213 	{

   214 	return iFlags & EMdEObjectFlagPlaceholder ? ETrue : EFalse;

   215 	}

   216 

   217 EXPORT_C void CMdEObjectCondition::SetNotPlaceholder(TBool aNotPlaceholder)

   218 	{

   219 	if( aNotPlaceholder )

   220 		{

   221 		iFlags |= EMdEObjectFlagPlaceholder; 

   222 		}

   223 	else

   224 		{

   225 		iFlags &= ~EMdEObjectFlagPlaceholder;

   226 		}

   227 	}

   228 

   229 EXPORT_C TBool CMdEObjectCondition::PlaceholderOnly() const

   230     {

   231     return iPlaceholdersOnly;

   232     }

   233 

   234 EXPORT_C void CMdEObjectCondition::SetPlaceholderOnly(TBool aPlaceholderOnly )

   235     {

   236     iPlaceholdersOnly = aPlaceholderOnly;

   237     }

   238 

   239 TUint32 CMdEObjectCondition::InternalQueryOptimizationFlags(TUint32& aFlags)

   240 	{

   241 	TUint32 optimizationFlags = EContainsObjectCondition;

   242 

   243 	if( iFlags & EMdEObjectFlagNotPresent )

   244 		{

   245 		optimizationFlags |= EContainsNotPresentCondition;

   246 		}

   247 

   248 	switch( iCompareMethod )

   249 		{

   250         case EObjectConditionCompareFreeText:

   251         case EObjectConditionCompareFreeTextContains:

   252         case EObjectConditionCompareFreeTextBeginsWith:

   253         case EObjectConditionCompareFreeTextEndsWith:

   254 			optimizationFlags |= EContainsFreetextCondition;

   255 			break;

   256 		default:

   257 			break;

   258 		}

   259 	

   260 	if( iPlaceholdersOnly )

   261 	    {

   262 	    optimizationFlags |= EContainsPlaceholdersOnly;

   263 	    }

   264 

   265 	aFlags |= optimizationFlags;

   266 	return optimizationFlags;

   267 	}

   268 

   269 TUint32 CMdEObjectCondition::RequiredBufferSize() const

   270 	{

   271 	TUint32 bufferSize = sizeof( TMdCObjectCondition );

   272 

   273 	switch( iCompareMethod )

   274 		{

   275 		case EObjectConditionCompareNone:

   276 			break;

   277 

   278 		case EObjectConditionCompareId:

   279 			{

   280 			// Required size for object ID

   281 			bufferSize += CMdCSerializationBuffer::KRequiredSizeForTItemId;

   282 			}

   283 			break;

   284 

   285 		case EObjectConditionCompareIds:

   286 			{

   287 			// Required size for object ID

   288 			bufferSize += CMdCSerializationBuffer::KRequiredSizeForTUint32; // count

   289 			if( iObjectIds )

   290 				{

   291 				bufferSize += CMdCSerializationBuffer::KRequiredSizeForTItemId * iObjectIds->Count();

   292 				}

   293 			}

   294 			break;

   295 

   296 	    case EObjectConditionCompareGuid:

   297 	    	{

   298 			// Required size for object GUID high (TInt64), object GUID low (TInt64)

   299 			bufferSize += 2 * CMdCSerializationBuffer::KRequiredSizeForTInt64;

   300 	    	}

   301 			break;

   302 

   303 	    case EObjectConditionCompareObjectDef:

   304 	    	{

   305 			// Required size for object def ID (TUint32)

   306 			bufferSize += CMdCSerializationBuffer::KRequiredSizeForTDefId;

   307 	    	}

   308 			break;

   309 

   310 	    case EObjectConditionCompareUri:

   311 	    case EObjectConditionCompareUriBeginsWith:

   312 	    case EObjectConditionCompareFreeText:

   313 	    case EObjectConditionCompareFreeTextContains:

   314 	    case EObjectConditionCompareFreeTextBeginsWith:

   315 	    case EObjectConditionCompareFreeTextEndsWith:

   316 	    	{

   317 			// Required size for string

   318 			bufferSize += CMdCSerializationBuffer::RequiredSize( *iString );

   319 	    	}

   320 			break;

   321 

   322 	    case EObjectConditionCompareUsageCount:

   323 	    	{

   324 	    	__ASSERT_DEBUG( iRange, User::Panic( _L("Incorrect range condition"), KErrArgument ) );

   325 	    	bufferSize += iRange->RequiredBufferSize();

   326 	    	}

   327 	    	break;

   328 

   329 	    default:

   330 			TMdEPanic::Panic( TMdEPanic::EInternal );

   331 			break;

   332 		}

   333 

   334 	return bufferSize;

   335 	}

   336 

   337 void CMdEObjectCondition::SerializeL(CMdCSerializationBuffer& aBuffer, 

   338 		TMdCOffset& aFreespaceOffset) const

   339 	{

   340 	const TUint32 conditionOffset = aBuffer.Position();

   341 	const TUint32 subConditionOffset = 

   342 			conditionOffset + sizeof( TMdCObjectCondition );

   343 

   344 	TMdCObjectCondition condition; 

   345 

   346 	condition.iConditionType = iType;

   347 	condition.iNegated = iNegated;

   348 	condition.iConfidentialityLevel = iConfidentialityLevel;

   349 	condition.iCompareMethod = iCompareMethod;

   350 	condition.iFlags = iFlags;

   351 	condition.iCondition = subConditionOffset;

   352 

   353 	aBuffer.PositionL( subConditionOffset );

   354 

   355 	switch( iCompareMethod )

   356 		{

   357 		case EObjectConditionCompareNone:

   358 			{

   359 			// nothing to compare, so "clear" condition offset

   360 			condition.iCondition = KNoOffset;

   361 			}

   362 			break;

   363 	

   364 		case EObjectConditionCompareId:

   365 			{

   366 			aBuffer.InsertL( iObjectId );

   367 			}

   368 			break;

   369 	

   370 		case EObjectConditionCompareIds:

   371 			{

   372 			if( iObjectIds )

   373 				{

   374 				const TInt count = iObjectIds->Count();

   375 				

   376 				aBuffer.InsertL( (TInt32)count );

   377 				

   378 				for( TInt i = 0; i < count; i++ )

   379 					{

   380 					aBuffer.InsertL( (*iObjectIds)[i] );

   381 					}

   382 				}

   383 			else

   384 				{

   385 				aBuffer.InsertL( TInt32( 0 ) );

   386 				}

   387 			}

   388 			break;

   389 	

   390 	    case EObjectConditionCompareGuid:

   391 			{

   392 			aBuffer.InsertL( iGuidHigh );

   393 			aBuffer.InsertL( iGuidLow );

   394 			}

   395 			break;

   396 

   397 	    case EObjectConditionCompareObjectDef:

   398 			{

   399 			aBuffer.InsertL( iObjectDef->Id() );

   400 			}

   401 			break;

   402 

   403 	    case EObjectConditionCompareUsageCount:

   404 			{

   405 			__ASSERT_DEBUG( iRange, User::Panic( 

   406 					_L("Incorrect range condition"), KErrArgument ) );

   407 			iRange->SerializeL( aBuffer );

   408 			}

   409 			break;

   410 

   411 	    case EObjectConditionCompareUri:

   412 	    case EObjectConditionCompareUriBeginsWith:

   413 	    case EObjectConditionCompareFreeText:

   414 	    case EObjectConditionCompareFreeTextContains:

   415 	    case EObjectConditionCompareFreeTextBeginsWith:

   416 	    case EObjectConditionCompareFreeTextEndsWith:

   417 			{

   418 			aBuffer.InsertL( *iString );

   419 			}

   420 			break;

   421 

   422 		default:

   423 			{

   424 #ifdef _DEBUG

   425 			TMdEPanic::Panic(TMdEPanic::EInternal);

   426 #endif

   427 			}

   428 			break;

   429 		}

   430 

   431 	// get position after sub condition

   432 	aFreespaceOffset = aBuffer.Position();

   433 

   434 	// serialize condition

   435 	aBuffer.PositionL( conditionOffset );

   436 	condition.SerializeL( aBuffer );

   437 	

   438 	// and move back to after sub condition

   439 	aBuffer.PositionL( aFreespaceOffset );

   440 	}