/*

* 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<TItemId>* 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<TItemId>* 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<TItemId>* 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<TItemId>;

	    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<TItemId>* 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 );

	}