--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsstar/wsstarpolicy/src/xorcompositeassertion.cpp Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,388 @@
+/*
+* 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 "xorcompositeassertion.h"
+#include "andcompositeassertion.h"
+#include "primitiveassertion.h"
+#include "policyassertion.h"
+
+
+CXorCompositeAssertion* CXorCompositeAssertion::NewL()
+{
+ CXorCompositeAssertion* pSelf = CXorCompositeAssertion::NewLC();
+ CleanupStack::Pop(pSelf);
+ return pSelf;
+
+}
+CXorCompositeAssertion* CXorCompositeAssertion::NewLC()
+{
+ CXorCompositeAssertion* pSelf = new (ELeave) CXorCompositeAssertion();
+ CleanupStack::PushL(pSelf);
+ pSelf->ConstructL();
+ return pSelf;
+
+}
+CXorCompositeAssertion* CXorCompositeAssertion::NewL(CXorCompositeAssertion* aValue)
+{
+ CXorCompositeAssertion* pSelf = CXorCompositeAssertion::NewLC(aValue);
+ CleanupStack::Pop(pSelf);
+ return pSelf;
+
+}
+CXorCompositeAssertion* CXorCompositeAssertion::NewLC(CXorCompositeAssertion* aValue)
+{
+ CXorCompositeAssertion* pSelf = new (ELeave) CXorCompositeAssertion();
+ CleanupStack::PushL(pSelf);
+ pSelf->ConstructL(aValue);
+ return pSelf;
+
+}
+
+CXorCompositeAssertion::~CXorCompositeAssertion()
+{
+
+}
+CXorCompositeAssertion::CXorCompositeAssertion()
+{
+
+}
+void CXorCompositeAssertion::ConstructL(CXorCompositeAssertion* aValue)
+{
+ ConstructL();
+
+ RPolicyTerms terms = aValue->GetTerms();
+
+ if(terms.Count() > 0)
+ AddTermsCopyL(terms);
+
+// terms.Close();
+
+}
+void CXorCompositeAssertion::ConstructL()
+{
+
+}
+
+//from CAssertion
+TAssertionType CXorCompositeAssertion::Type()
+{
+ return ECompositeXorType;
+}
+void CXorCompositeAssertion::AddTerm(MAssertion* aAssertion)
+{
+ if ( IsNormalized()
+ && (aAssertion->Type() == ECompositeAndType)
+ && (aAssertion->IsNormalized()
+ ))
+ {
+ SetNormalized(EFalse);
+ }
+ CAssertion::AddTerm(aAssertion);
+}
+void CXorCompositeAssertion::AddTermCopyL(MAssertion* aAssertion)
+{
+ if ( IsNormalized()
+ && (aAssertion->Type() == ECompositeAndType)
+ && (aAssertion->IsNormalized()
+ ))
+ {
+ SetNormalized(EFalse);
+ }
+ CAssertion::AddTermCopyL(aAssertion);
+
+}
+MAssertion* CXorCompositeAssertion::NormalizeL(CPolicyRegistry* aRegistry)
+{
+ if (IsNormalized()) {
+ return this;
+ }
+
+ CXorCompositeAssertion* XOR = CXorCompositeAssertion::NewL();
+
+ if (IsEmpty()) {
+ XOR->SetNormalized(true);
+ return XOR;
+ }
+
+ RPointerArray<MAssertion> terms1 = GetTerms();
+ TInt termCount = terms1.Count();
+ for (TInt i = 0; i< termCount; i++)
+ {
+
+ MAssertion* term = terms1[i];
+ MAssertion* result = term;
+ if(!dynamic_cast<CPolicyAssertion*>(term))
+ {
+ result = term->NormalizeL(aRegistry);
+ }
+
+ if (dynamic_cast<CPolicyAssertion*>(result))
+ {
+ CAndCompositeAssertion* wrapper = CAndCompositeAssertion::NewL();
+
+ RPolicyTerms termsPol1 = result->GetTerms();
+ wrapper->AddTermsCopyL(termsPol1);
+
+ if(result != term)
+ {
+ CPolicyAssertion* eleToDel = (CPolicyAssertion*)result;
+ delete eleToDel;
+ }
+ result = NULL;
+
+ result = wrapper->NormalizeL(aRegistry);
+ delete wrapper;
+
+ if (dynamic_cast<CAndCompositeAssertion*>(result))
+ {
+ XOR->AddTerm(result);
+ }
+ else
+ {
+ RPolicyTerms termsPol2 = result->GetTerms();
+ XOR->AddTermsCopyL(termsPol2);
+
+ CPolicyAssertion* eleToDel = (CPolicyAssertion*)result;
+ delete eleToDel;
+// termsPol2.Close();
+ }
+ continue;
+ }
+
+ if (dynamic_cast<CPrimitiveAssertion*>(result))
+ {
+ CAndCompositeAssertion* wrapper = CAndCompositeAssertion::NewL();
+ wrapper->AddTermCopyL(result);
+ XOR->AddTerm(wrapper);
+ CPrimitiveAssertion* eleToDel = (CPrimitiveAssertion*)result;
+ delete eleToDel;
+ result = NULL;
+ continue;
+ }
+
+ if (dynamic_cast<CXorCompositeAssertion*>(result))
+ {
+ RPolicyTerms termsPol3 = result->GetTerms();
+ XOR->AddTermsCopyL(termsPol3);
+ CXorCompositeAssertion* eleToDel = (CXorCompositeAssertion*)result;
+ delete eleToDel;
+ continue;
+ }
+
+ if (dynamic_cast<CAndCompositeAssertion*>(result))
+ {
+ XOR->AddTerm(result);
+ }
+ }
+// terms1.Close();
+ XOR->SetNormalized(ETrue);
+ return XOR;
+}
+MAssertion* CXorCompositeAssertion::IntersectL(MAssertion* aAssertion, CPolicyRegistry* aRegistry)
+{
+ MAssertion* normalizedMe = (IsNormalized()) ? this : NormalizeL(aRegistry);
+
+ if (!(dynamic_cast<CXorCompositeAssertion*>(normalizedMe)))
+ {
+ return normalizedMe->IntersectL(aAssertion, aRegistry);
+ }
+
+ MAssertion* target = (aAssertion->IsNormalized()) ? aAssertion : aAssertion->NormalizeL(aRegistry);
+ short type = target->Type();
+
+ RPolicyTerms terms = normalizedMe->GetTerms();
+
+ switch (type) {
+
+ case ECompositePolicyType: {
+ CPolicyAssertion* nPOLICY = CPolicyAssertion::NewL();
+ CXorCompositeAssertion* term = (CXorCompositeAssertion*)terms[0];
+ nPOLICY->AddTerm(term->IntersectL(target, NULL));
+ return nPOLICY;
+ }
+
+ case ECompositeXorType: {
+ CXorCompositeAssertion* nXOR = CXorCompositeAssertion::NewL();
+
+ MAssertion* asser = NULL;
+ CAndCompositeAssertion* AND;
+
+ for (TInt i=0; i< terms.Count(); i++)
+ {
+ AND = (CAndCompositeAssertion*)terms[i];
+ RPolicyTerms tgtTerms = target->GetTerms();
+ for (TInt j=0; j< tgtTerms.Count(); j++)
+ {
+ asser = NULL;
+ asser = AND->IntersectL((CAndCompositeAssertion*)tgtTerms[j], NULL);
+
+ if (dynamic_cast<CAndCompositeAssertion*>(asser))
+ {
+ nXOR->AddTerm(asser);
+ }
+ else
+ {
+ DeleteAssertion(asser);
+ }
+
+
+
+ }
+ }
+
+ return nXOR;
+ }
+
+ case ECompositeAndType: {
+ CXorCompositeAssertion* nXOR = CXorCompositeAssertion::NewL();
+ MAssertion* asser;
+
+ for (TInt i=0; i< terms.Count(); i++)
+ {
+ asser = ((CAndCompositeAssertion*) terms[i])->IntersectL(target, NULL);
+
+ if (dynamic_cast<CAndCompositeAssertion*>(asser))
+ {
+ nXOR->AddTerm(asser);
+ }
+ else
+ {
+ DeleteAssertion(asser);
+ }
+ }
+ return nXOR;
+ }
+
+ case EPrimitiveType: {
+ CXorCompositeAssertion* nXOR = CXorCompositeAssertion::NewL();
+
+ MAssertion* asser;
+ for (TInt i=0; i< terms.Count(); i++)
+ {
+ asser = ((CAndCompositeAssertion*)terms[i])->IntersectL(target, NULL);
+
+ if (dynamic_cast<CAndCompositeAssertion*>(asser))
+ {
+ nXOR->AddTerm(asser);
+ }
+ else
+ {
+ DeleteAssertion(asser);
+ }
+
+ }
+ return nXOR;
+ }
+
+ default: {
+ }
+
+ }
+return NULL;
+}
+MAssertion* CXorCompositeAssertion::MergeL(MAssertion* aAssertion, CPolicyRegistry* aRegistry)
+{
+ MAssertion* normalizedMe = (IsNormalized()) ? this : NormalizeL(aRegistry);
+
+ if (!(dynamic_cast<CXorCompositeAssertion*>(normalizedMe)))
+ {
+ return normalizedMe->MergeL(aAssertion, aRegistry);
+ }
+
+ MAssertion* target = (aAssertion->IsNormalized()) ? aAssertion : aAssertion->NormalizeL(aRegistry);
+
+ short type = target->Type();
+
+ switch (type)
+ {
+
+ case ECompositePolicyType:
+ {
+
+ CPolicyAssertion* nPOLICY = CPolicyAssertion::NewL();
+ nPOLICY->AddTerm(normalizedMe->MergeL(target->GetTerms()[0]));
+ return nPOLICY;
+ }
+
+ case ECompositeXorType:
+ {
+
+ CXorCompositeAssertion* nXOR = CXorCompositeAssertion::NewL();
+ RPolicyTerms xTerms = normalizedMe->GetTerms();
+ for (TInt i=0; i< xTerms.Count(); i++)
+ {
+ CAndCompositeAssertion* AND = (CAndCompositeAssertion*) xTerms[i];
+
+ RPolicyTerms targetTerms = target->GetTerms();
+ for (TInt j=0; j< targetTerms.Count(); j++)
+ {
+ MAssertion* tgtTerm = targetTerms[j];
+ nXOR->AddTerm(AND->MergeL(tgtTerm, NULL));
+ }
+
+ if (target->IsEmpty() && AND->IsEmpty()) {
+ /*
+ * " <wsp:ExactlyOne> <wsp:All/>
+ * </wsp:ExactlyOne>".intersect(" <wsp:ExactlyOne/>")
+ */
+ nXOR->AddTermCopyL(AND);
+ }
+ }
+
+ return nXOR;
+ }
+
+ case ECompositeAndType:
+ {
+
+ CXorCompositeAssertion* nXOR = CXorCompositeAssertion::NewL();
+ RPolicyTerms xTerms = normalizedMe->GetTerms();
+ for (TInt i=0; i< xTerms.Count(); i++)
+ {
+ CAndCompositeAssertion* term = (CAndCompositeAssertion*)xTerms[i];
+ nXOR->AddTerm(term->MergeL(target, NULL));
+ }
+ return nXOR;
+ }
+
+ case EPrimitiveType:
+ {
+ CXorCompositeAssertion* nXOR = CXorCompositeAssertion::NewL();
+
+ RPolicyTerms xTerms = normalizedMe->GetTerms();
+ for (TInt i=0; i< xTerms.Count(); i++)
+ {
+ CAndCompositeAssertion* tgtTerm = (CAndCompositeAssertion*)xTerms[i];
+ nXOR->AddTerm(tgtTerm->MergeL(target, NULL));
+ }
+
+ return nXOR;
+ }
+
+ default:
+ {
+ }
+
+ }
+return NULL;
+}