/*

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

    // Lock children as well.

    for( TInt i = iChildren.Count()- 1; i >=0; i-- )

        {

        iChildren[i]->SetLocked(aLocked);

        }

    }

TUint32 CMdELogicCondition::InternalQueryOptimizationFlags(TUint32& aFlags)

	{

	// get flag from childrens

	for( TInt i = iChildren.Count() - 1; i >=0; 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 = count - 1; i >=0; 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<TItemId>& 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<TItemId>& 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;

    }