/*
* 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:
*
*/
#include "policyassertion.h"
#include "xorcompositeassertion.h"
#include "andcompositeassertion.h"
#include "wspolicywriter.h"
#include "sendebug.h"
CPolicyAssertion* CPolicyAssertion::NewL()
{
CPolicyAssertion* pSelf = CPolicyAssertion::NewLC();
CleanupStack::Pop(pSelf);
return pSelf;
}
CPolicyAssertion* CPolicyAssertion::NewLC()
{
CPolicyAssertion* pSelf = new (ELeave) CPolicyAssertion();
CleanupStack::PushL(pSelf);
pSelf->ConstructL();
return pSelf;
}
CPolicyAssertion* CPolicyAssertion::NewL(CPolicyAssertion* aValue)
{
CPolicyAssertion* pSelf = CPolicyAssertion::NewLC(aValue);
CleanupStack::Pop(pSelf);
return pSelf;
}
CPolicyAssertion* CPolicyAssertion::NewLC(CPolicyAssertion* aValue)
{
CPolicyAssertion* pSelf = new (ELeave) CPolicyAssertion();
CleanupStack::PushL(pSelf);
pSelf->ConstructL(aValue);
return pSelf;
}
CPolicyAssertion::~CPolicyAssertion()
{
delete iName;
delete iId;
delete iMetadataEndpoint;
}
CPolicyAssertion::CPolicyAssertion():
iName(NULL),
iId(NULL),
iMetadataEndpoint(NULL)
{
}
void CPolicyAssertion::ConstructL()
{
}
void CPolicyAssertion::ConstructL(CPolicyAssertion* aValue)
{
ConstructL();
RPolicyTerms terms = aValue->GetTerms();
if(terms.Count() > 0)
AddTermsCopyL(terms);
}
TAssertionType CPolicyAssertion::Type()
{
return ECompositePolicyType;
}
MAssertion* CPolicyAssertion::NormalizeL()
{
return NormalizeL(NULL);
}
MAssertion* CPolicyAssertion::NormalizeL(CPolicyRegistry* aRegistry)
{
if (IsNormalized())
{
return this;
}
// TPtrC8 xmlBase = Name();
// TPtrC8 id = Id();
CPolicyAssertion* policy = CPolicyAssertion::NewL(); //new Policy(xmlBase, id);
CXorCompositeAssertion* XOR = CXorCompositeAssertion::NewL();
CAndCompositeAssertion* AND = CAndCompositeAssertion::NewL();
RPolicyTerms childXorTermList;
RPointerArray<MAssertion> terms = GetTerms();
MAssertion* term = NULL;
MAssertion* result = NULL;
TInt termCount = terms.Count();
for (TInt i = 0; i< termCount; i++)
{
term = terms[i];
result = term->NormalizeL(aRegistry);
if(dynamic_cast<CPolicyAssertion*>(result))
{
CXorCompositeAssertion* tempXor = (CXorCompositeAssertion*) result->GetTerms()[0];
if (tempXor->Size() != 1)
{
//result is Policy and have an XOR
//delete the policy and put XOR as result
// result = Xor;
CPolicyAssertion* ele = (CPolicyAssertion*)result;
result = NULL;
result = CXorCompositeAssertion::NewL();
RPolicyTerms xorTerms = tempXor->GetTerms();
result->AddTermsCopyL(xorTerms);
delete ele;
ele = NULL;
}
else
{
MAssertion* tempTerm = tempXor->GetTerms()[0];
if(tempTerm)
{
RPolicyTerms terms2 = tempTerm->GetTerms();
AND->AddTermsCopyL(terms2);
// terms2.Close();
}
CPolicyAssertion* eleToDel = (CPolicyAssertion*)result;
delete eleToDel;
eleToDel = NULL;
result = NULL;
continue;
}
}
if(dynamic_cast<CXorCompositeAssertion*>(result))
{
if (((CXorCompositeAssertion*) result)->IsEmpty())
{
// CXorCompositeAssertion* emptyXor = CXorCompositeAssertion::NewL();
// emptyXor->SetNormalized(ETrue);
// result->AddTermL(AND);
policy->AddTerm(result);
policy->SetNormalized(ETrue);
delete AND;
delete XOR;
childXorTermList.Close();
return policy;
}
childXorTermList.Append(result);
continue;
}
if(dynamic_cast<CAndCompositeAssertion*>(result))
{
if (result->IsEmpty())
{
CAndCompositeAssertion* emptyAnd = CAndCompositeAssertion::NewL();
XOR->AddTerm(emptyAnd);
}
else
{
RPolicyTerms terms3 = result->GetTerms();
AND->AddTermsCopyL(terms3);
}
CAndCompositeAssertion* eletoDel = (CAndCompositeAssertion*)result;
delete eletoDel;
continue;
}
AND->AddTerm(result);
}
////////////////////////////////////////////////////
////////////////////////////////////////////////////
// processing child-XORCompositeAssertions
if (childXorTermList.Count() > 1) {
for (TInt i = 0; i < childXorTermList.Count(); i++) {
for (TInt j = i; j < childXorTermList.Count(); j++) {
if (i != j) {
CXorCompositeAssertion* xorTermA = (CXorCompositeAssertion*) childXorTermList[i];
CXorCompositeAssertion* xorTermB = (CXorCompositeAssertion*) childXorTermList[j];
RPolicyTerms iterA = xorTermA->GetTerms();
for (TInt k = 0; k< iterA.Count(); k++)
{
MAssertion* andTermA = iterA[k];
RPolicyTerms iterB = xorTermB->GetTerms();
for (TInt l = 0; l< iterB.Count(); l++)
{
MAssertion* andTermB = iterB[l];
CAndCompositeAssertion* anAndTerm = CAndCompositeAssertion::NewL();
RPolicyTerms termsAA = andTermA->GetTerms();
RPolicyTerms termsBB = andTermB->GetTerms();
anAndTerm->AddTermsCopyL(termsAA);
anAndTerm->AddTermsCopyL(termsBB);
// termsBB.Close();
// termsAA.Close();
XOR->AddTerm(anAndTerm);
}
// iterB.Close();
}
// iterA.Close();
}
}
}
for (TInt x = 0; x < childXorTermList.Count(); x++)
{
CXorCompositeAssertion* xorTermTemp = (CXorCompositeAssertion*)childXorTermList[x];
if(xorTermTemp)
delete xorTermTemp;
}
}
else if (childXorTermList.Count() == 1)
{
CXorCompositeAssertion* xorTerm = (CXorCompositeAssertion*)childXorTermList[0];
XOR->AddTermsCopyL(xorTerm->GetTerms());
delete xorTerm;
}
else if (childXorTermList.Count() == 0)
{
if(AND->Size() > 0)
XOR->AddTerm(AND);
else
delete AND;
policy->AddTerm(XOR);
policy->SetNormalized(ETrue);
childXorTermList.Close();
return policy;
}
childXorTermList.Close();
////////////////////////////////////////////////////
////////////////////////////////////////////////////
RPolicyTerms primTerms = AND->GetTerms();
RPolicyTerms andTerms = XOR->GetTerms();
for(TInt p = 0; p < andTerms.Count(); p++)
{
MAssertion* anAndTerm = andTerms[p];
anAndTerm->AddTermsCopyL(primTerms);
}
delete AND;
policy->AddTerm(XOR);
policy->SetNormalized(ETrue);
return policy;
}
MAssertion* CPolicyAssertion::IntersectL(MAssertion* aAssertion, CPolicyRegistry* aRegistry)
{
MAssertion* normalizedMe = (IsNormalized()) ? this : NormalizeL(aRegistry);
if (!(dynamic_cast<CPolicyAssertion*>(normalizedMe)))
{
return normalizedMe->IntersectL(aAssertion, aRegistry);
}
MAssertion* target = (aAssertion->IsNormalized()) ? aAssertion : aAssertion->NormalizeL(aRegistry);
short type = target->Type();
switch (type)
{
case ECompositePolicyType:
{
CPolicyAssertion* nPOLICY = CPolicyAssertion::NewL();
CXorCompositeAssertion* norm1 = (CXorCompositeAssertion*) normalizedMe->GetTerms()[0];
nPOLICY->AddTerm(norm1->IntersectL((CXorCompositeAssertion*) target->GetTerms()[0], NULL));
return nPOLICY;
}
case ECompositeXorType:
case ECompositeAndType:
case EPrimitiveType:
{
CPolicyAssertion* nPOLICY = CPolicyAssertion::NewL();
nPOLICY->AddTerm((normalizedMe->GetTerms()[0])->IntersectL(target, NULL));
return nPOLICY;
}
default:
{
}
}
return NULL;
}
MAssertion* CPolicyAssertion::MergeL(MAssertion* aAssertion, CPolicyRegistry* aRegistry)
{
MAssertion* normalizedMe = (IsNormalized()) ? this : NormalizeL(aRegistry);
if (!(dynamic_cast<CPolicyAssertion*>(normalizedMe)))
{
return normalizedMe->MergeL(aAssertion, aRegistry);
}
CPolicyAssertion* nPOLICY = CPolicyAssertion::NewL();
MAssertion* target = (aAssertion->IsNormalized()) ? aAssertion : aAssertion->NormalizeL(aRegistry);
short type = target->Type();
RPolicyTerms terms = normalizedMe->GetTerms();
if(terms.Count() > 0)
{
CXorCompositeAssertion* xorTerm = (CXorCompositeAssertion*)terms[0];
switch (type)
{
case ECompositePolicyType:
{
RPolicyTerms tgtTerms = target->GetTerms();
if(tgtTerms.Count() > 0)
{
CXorCompositeAssertion* tgtTerm = (CXorCompositeAssertion*)tgtTerms[0];
MAssertion* result = xorTerm->MergeL(tgtTerm, NULL);
nPOLICY->AddTerm(result);
}
return nPOLICY;
}
case ECompositeXorType:
case ECompositeAndType:
case EPrimitiveType:
{
MAssertion* result = xorTerm->MergeL(target, NULL);
nPOLICY->AddTerm(result);
return nPOLICY;
}
default:
{
}
}
}
return NULL;
}
void CPolicyAssertion::SetNameL(TDesC8& aName)
{
iName = aName.AllocL();
}
void CPolicyAssertion::SetIdL(TDesC8& aId)
{
iId = aId.AllocL();
}
TPtrC8 CPolicyAssertion::Name()
{
return iName->Des();
}
TPtrC8 CPolicyAssertion::Id()
{
return iId->Des();
}
TPtrC8 CPolicyAssertion::PolicyURI()
{
return iName->Des();
}