// Copyright (c) 2007-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:
// Name        : resourcecondition.cpp
// Part of     : System Startup / Condition
// Implementation of ResourceCondition class
// Version     : %version: 1 %
// This material, including documentation and any related computer
// programs, is protected by copyright controlled by Nokia.  All
// rights are reserved.  Copying, including reproducing, storing,
// adapting or translating, any or all of this material requires the
// prior written consent of Nokia.  This material also contains
// confidential information which may not be disclosed to others
// without the prior written consent of Nokia.
// Template version: 4.1
// Nokia Core OS *
// File renamed from resourcecondition.cpp to conditionevaluate.cpp as part of Core OS transfer.
//



#include "conditionevaluate.h"
#include "cndlogical.h"
#include "cndfeature.h"
#include "cndcentralrepository.h"
#include "cndpublishsubscribe.h"
#include "cndsystemwideproperty.h"

CConditionEvaluate::CConditionEvaluate()
	{
	}

EXPORT_C CConditionEvaluate::~CConditionEvaluate()
	{
	}

EXPORT_C CConditionEvaluate* CConditionEvaluate::NewLC()
	{
	CConditionEvaluate* self = CConditionEvaluate::NewL();
	CleanupStack::PushL(self);
	return self;
	}

EXPORT_C CConditionEvaluate* CConditionEvaluate::NewL()
	{
	CConditionEvaluate* self = new (ELeave)CConditionEvaluate();
	return self;
	}

CConditionEvaluateBase* CConditionEvaluate::ReadConditionOnFeatureMatchL(TResourceReader& aReader)
    {
    const TInt featureId = aReader.ReadInt32();
    return CCndFeature::NewL(ECompareValue, featureId);
    }

CConditionEvaluateBase* CConditionEvaluate::ReadConditionOnFeatureL(TResourceReader& aReader)
    {
    const TInt featureId = aReader.ReadInt32();
    const TUint32 aCndValue = aReader.ReadUint32();
    return CCndFeature::NewL(ECompareFeatureData, featureId, aCndValue);
    }

CConditionEvaluateBase* CConditionEvaluate::ReadConditionOnCentRepFlagL(TResourceReader& aReader)
    {
    const TInt repositoryId = aReader.ReadInt32();
    const TUint32 key = aReader.ReadUint32();
    const TInt mask = aReader.ReadInt32();
    return CCndCentralRepository::NewL(ECompareBitwiseAnd, repositoryId, key, mask);
    }

CConditionEvaluateBase* CConditionEvaluate::ReadConditionOnCentRepMatchL(TResourceReader& aReader)
    {
    const TInt repositoryId = aReader.ReadInt32();
    const TUint32 key = aReader.ReadUint32();
    const TInt value = aReader.ReadInt32();
    return CCndCentralRepository::NewL(ECompareValue, repositoryId, key, value );
    }

CConditionEvaluateBase* CConditionEvaluate::ReadConditionOnPubSubFlagL(TResourceReader& aReader)
    {
    const TInt category = aReader.ReadInt32();
    const TUint32 key = aReader.ReadUint32();
    const TInt mask = aReader.ReadInt32();

    return CCndPublishSubscribe::NewL(ECompareBitwiseAnd, category, key, mask);
    }

CConditionEvaluateBase* CConditionEvaluate::ReadConditionOnPubSubMatchL(TResourceReader& aReader)
    {
    const TInt category = aReader.ReadInt32();
    const TUint32 key = aReader.ReadUint32();
    const TInt value = aReader.ReadInt32();

    return CCndPublishSubscribe::NewL(ECompareValue, category, key, value);
    }

CConditionEvaluateBase* CConditionEvaluate::ReadConditionOnSwpMatchL(TResourceReader& aReader)
    {
    const TUint32 key = aReader.ReadUint32();
    const TInt value = aReader.ReadInt32();

    return CCndSwp::NewL(ECompareValue, key, value);
    }
    
CConditionEvaluateBase* CConditionEvaluate::ReadConditionOnSwpFlagL(TResourceReader& aReader)
    {
    const TUint32 key = aReader.ReadUint32();
    const TInt mask = aReader.ReadInt32();

    return CCndSwp::NewL(ECompareBitwiseAnd, key, mask);
    }
    
CConditionEvaluateBase* CConditionEvaluate::ReadLogicalNotL(const CResourceFile& aResourceFile,TResourceReader& aReader,
		RArray<TUint32>& aUsedResourceIds)
    {
    const TUint32 resourceId = aReader.ReadUint32();
    CConditionEvaluateBase* sub = DoEvaluateLC(aResourceFile, resourceId, aUsedResourceIds);
    CConditionEvaluateBase* retVal = new (ELeave) CLogicalNot(sub);
    CleanupStack::Pop(sub); // CLogicalNot owns it now
    return retVal;
    }

CConditionEvaluateBase* CConditionEvaluate::ReadLogicalAndL(const CResourceFile& aResourceFile,TResourceReader& aReader,
		RArray<TUint32>& aUsedResourceIds)
    {
    const TUint32 lhsId = aReader.ReadUint32();
    const TUint32 rhsId = aReader.ReadUint32();

    CConditionEvaluateBase* lhs = DoEvaluateLC(aResourceFile, lhsId, aUsedResourceIds);
    CConditionEvaluateBase* rhs = DoEvaluateLC(aResourceFile, rhsId, aUsedResourceIds);
    CConditionEvaluateBase* retVal = new (ELeave) CLogicalAnd(lhs, rhs);
    CleanupStack::Pop(rhs); // CLogicalAnd owns it now
    CleanupStack::Pop(lhs); // CLogicalAnd owns it now

    return retVal;
    }

CConditionEvaluateBase* CConditionEvaluate::ReadLogicalOrL(const CResourceFile& aResourceFile,TResourceReader& aReader,
		RArray<TUint32>& aUsedResourceIds)
    {
    const TUint32 lhsId = aReader.ReadUint32();
    const TUint32 rhsId = aReader.ReadUint32();
    CConditionEvaluateBase* lhs = DoEvaluateLC(aResourceFile, lhsId, aUsedResourceIds);
    CConditionEvaluateBase* rhs = DoEvaluateLC(aResourceFile, rhsId, aUsedResourceIds);
    CConditionEvaluateBase* retVal = new (ELeave) CLogicalOr(lhs, rhs);
    CleanupStack::Pop(rhs); // CLogicalOr owns it now
    CleanupStack::Pop(lhs); // CLogicalOr owns it now

    return retVal;
    }

CConditionEvaluateBase* CConditionEvaluate::DoEvaluateLC(const CResourceFile& aResourceFile, const TInt aResourceId,
									RArray<TUint32>& aUsedResourceIds)
	{
    // Check for any recursive conditions
    TInt idx = aUsedResourceIds.FindReverse(aResourceId);
    if (0 <= idx)
        {
        //Leave in case of any recursive condition
        User::Leave(KErrCorrupt);
        }
    aUsedResourceIds.AppendL(aResourceId);

    HBufC8* buf = aResourceFile.AllocReadLC(aResourceId);
    TResourceReader reader;
    reader.SetBuffer(buf);

    TUint16 type = reader.ReadUint16();
    CConditionEvaluateBase* retVal = NULL;

    switch (type)
        {
    case EFeatureFlag:
    	retVal = ReadConditionOnFeatureMatchL(reader);
        break;
    case EFeatureFlagData:
    	retVal = ReadConditionOnFeatureL(reader);
    	break;
    case ECentRepFlag:
        retVal = ReadConditionOnCentRepFlagL(reader);
        break;
    case ECentRepIntVal:
        retVal = ReadConditionOnCentRepMatchL(reader);
        break;
    case EPubSubFlag:
        retVal = ReadConditionOnPubSubFlagL(reader);
        break;
    case EPubSubIntVal:
        retVal = ReadConditionOnPubSubMatchL(reader);
        break;
    case ELogicalNot:
        retVal = ReadLogicalNotL(aResourceFile, reader, aUsedResourceIds);
        break;
    case ELogicalAnd:
        retVal = ReadLogicalAndL(aResourceFile, reader, aUsedResourceIds);
        break;
    case ELogicalOr:
        retVal = ReadLogicalOrL(aResourceFile, reader, aUsedResourceIds);
        break;
    case ESwpIntVal:
        retVal = ReadConditionOnSwpMatchL(reader);
        break;
    case ESwpFlag:
        retVal = ReadConditionOnSwpFlagL(reader);
        break;    
    default:
        User::Leave(KErrCorrupt);
        }

    aUsedResourceIds.Remove(aUsedResourceIds.Count() - 1);
    CleanupStack::PopAndDestroy(buf);
    CleanupStack::PushL(retVal);
    return retVal;
	}

EXPORT_C TBool CConditionEvaluate::EvaluateL(const CResourceFile& aResourceFile, const TInt aResourceId)
    {
    RArray<TUint32> array;
    CleanupClosePushL(array);

    CConditionEvaluateBase* expr = DoEvaluateLC(aResourceFile, aResourceId, array);
    TBool retVal = expr->EvaluateL();

    CleanupStack::PopAndDestroy(expr);
    CleanupStack::PopAndDestroy(&array);
    return retVal;
    }