diff -r 000000000000 -r 62f9d29f7211 webservices/wsstar/wsstarpolicy/src/andcompositeassertion.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsstar/wsstarpolicy/src/andcompositeassertion.cpp	Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,486 @@
+/*
+* 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 "andcompositeassertion.h"
+#include "xorcompositeassertion.h"
+#include "primitiveassertion.h"
+#include "policyassertion.h"
+
+CAndCompositeAssertion* CAndCompositeAssertion::NewL()
+{
+    CAndCompositeAssertion* pSelf = CAndCompositeAssertion::NewLC();
+    CleanupStack::Pop(pSelf);
+    return pSelf;
+   
+}
+CAndCompositeAssertion* CAndCompositeAssertion::NewLC()
+{
+    CAndCompositeAssertion* pSelf = new (ELeave) CAndCompositeAssertion();
+    CleanupStack::PushL(pSelf);
+    pSelf->ConstructL();
+    return pSelf;
+ 
+}
+CAndCompositeAssertion* CAndCompositeAssertion::NewL(CAndCompositeAssertion* aValue)
+{
+    CAndCompositeAssertion* pSelf = CAndCompositeAssertion::NewLC(aValue);
+    CleanupStack::Pop(pSelf);
+    return pSelf;
+    
+}
+CAndCompositeAssertion* CAndCompositeAssertion::NewLC(CAndCompositeAssertion* aValue)
+{
+    CAndCompositeAssertion* pSelf = new (ELeave) CAndCompositeAssertion();
+    CleanupStack::PushL(pSelf);
+    pSelf->ConstructL(aValue);
+    return pSelf;
+    
+}
+
+CAndCompositeAssertion::~CAndCompositeAssertion()
+{
+    
+}
+CAndCompositeAssertion::CAndCompositeAssertion()
+{
+    
+}
+void CAndCompositeAssertion::ConstructL()
+{
+    
+} 
+void CAndCompositeAssertion::ConstructL(CAndCompositeAssertion* aValue)
+{
+    ConstructL();
+
+    RPolicyTerms terms = aValue->GetTerms();
+    
+    if(terms.Count() > 0)
+        AddTermsCopyL(terms);
+    
+ //   terms.Close();    
+}
+
+TAssertionType CAndCompositeAssertion::Type()
+{
+  return ECompositeAndType;  
+}
+void  CAndCompositeAssertion::AddTerm(MAssertion* aAssertion)
+{
+	if ((IsNormalized() && (aAssertion->Type() == EPrimitiveType))) 
+	{
+			SetNormalized(EFalse);
+	}
+	
+	CAssertion::AddTerm(aAssertion);    
+}
+void CAndCompositeAssertion::AddTermCopyL(MAssertion* aAssertion)
+{
+ 	if ((IsNormalized() && (aAssertion->Type() == EPrimitiveType))) 
+	{
+			SetNormalized(EFalse);
+	}
+	
+	CAssertion::AddTermCopyL(aAssertion);    
+}
+MAssertion*	CAndCompositeAssertion::NormalizeL(CPolicyRegistry* aRegistry){
+
+	if (IsNormalized()) 
+	{
+		return this;
+	}
+
+	CAndCompositeAssertion* AND = CAndCompositeAssertion::NewL();
+
+	if (IsEmpty()) 
+	{
+		AND->SetNormalized(ETrue);
+		return AND;
+	}
+
+/////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////
+	RPolicyTerms XORs;
+
+	RPointerArray<MAssertion> terms1 = GetTerms();
+	MAssertion* term = NULL;
+    TInt termCount = terms1.Count();
+
+    for (TInt i = 0; i< termCount; i++)
+    {
+        
+		term = terms1[i];
+		MAssertion* result = term;
+		if(!dynamic_cast<CPolicyAssertion*>(term))
+		{
+		    //term has new value object, no need to copy
+		    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;
+			//term has new value object, no need to copy
+			result = wrapper->NormalizeL(aRegistry);
+			delete wrapper;
+//			termsPol1.Close(); //not needed any more
+		}
+
+		if (dynamic_cast<CXorCompositeAssertion*>(result)) 
+		{
+
+			if (result->IsEmpty()) 
+			{
+                result->SetNormalized(true);
+				delete AND;
+                return result;
+			}
+			XORs.Append(result);
+			continue;
+
+		}
+
+		if (dynamic_cast<CAndCompositeAssertion*>(result)) 
+		{
+  			if (result->IsEmpty()) 
+			{
+			    CAndCompositeAssertion* eleToDel = (CAndCompositeAssertion*)result;
+			    delete eleToDel;
+			}
+			else
+			{
+    		    RPolicyTerms termsPol2 = result->GetTerms();
+    			AND->AddTermsCopyL(termsPol2);
+
+			    CAndCompositeAssertion* eleToDel = (CAndCompositeAssertion*)result;
+			    delete eleToDel;
+    			
+//    			termsPol2.Close();
+			}
+			continue;
+		}
+
+		AND->AddTerm(result);
+    }
+    
+	// processing child-XORCompositeAssertions
+
+/////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////
+    
+    CXorCompositeAssertion* XOR = CXorCompositeAssertion::NewL();
+	
+	if (XORs.Count() > 1) 
+	{
+		for (int i = 0; i < XORs.Count(); i++) 
+		{
+
+			for (int j = i; j < XORs.Count(); j++) 
+			{
+
+				if (i != j) 
+				{
+					CXorCompositeAssertion* XOR_A = (CXorCompositeAssertion*) XORs[i];
+					CXorCompositeAssertion* XOR_B = (CXorCompositeAssertion*) XORs[j];
+
+					RPolicyTerms iterA = XOR_A->GetTerms();
+					for (TInt k = 0; k< iterA.Count(); k++) 
+					{
+					    MAssertion* anAND_A = iterA[k];
+						RPolicyTerms iterB = XOR_B->GetTerms();
+
+						for (TInt l = 0; l< iterB.Count(); l++)
+						{
+
+							MAssertion* anAND_B = iterB[l];
+							CAndCompositeAssertion* nAND = CAndCompositeAssertion::NewL();
+							RPolicyTerms termsAA = anAND_A->GetTerms();
+							RPolicyTerms termsBB = anAND_B->GetTerms();
+							nAND->AddTermsCopyL(termsAA);
+							nAND->AddTermsCopyL(termsBB);
+//                            termsAA.Close();
+  //                          termsBB.Close();
+							XOR->AddTerm(nAND);
+						}
+//						iterB.Close();
+					}
+//					iterA.Close();
+				}
+			}
+		}
+
+	} 
+	else if (XORs.Count() == 1) 
+	{	
+		CXorCompositeAssertion* XORterm = (CXorCompositeAssertion*)XORs[0];
+	    RPolicyTerms termsPol3 = XORterm->GetTerms();
+		XOR->AddTermsCopyL(termsPol3);
+		delete XORterm;
+//		termsPol3.Close();
+	}
+
+	XORs.Close();
+
+/////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////
+	
+	if (XOR->IsEmpty())
+	{
+	    delete XOR;
+		AND->SetNormalized(true);
+		return AND;
+	}
+
+	if (AND->IsEmpty()) 
+	{
+	    delete AND;
+		XOR->SetNormalized(true);
+		return XOR;
+	}
+
+/////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////
+
+	RPolicyTerms primTerms = AND->GetTerms();
+	RPolicyTerms xTerms = XOR->GetTerms();
+
+	for (TInt x = 0; x< xTerms.Count(); x++) 
+	{
+		MAssertion* rAND = xTerms[x];
+		rAND->AddTermsCopyL(primTerms);
+	}
+
+    delete AND; //we have copied everythign from AND so now we dont need it
+    
+	XOR->SetNormalized(ETrue);
+	return XOR;
+    
+}         
+MAssertion* CAndCompositeAssertion::IntersectL(MAssertion* aAssertion, CPolicyRegistry* aRegistry)
+{
+    MAssertion* normalizedMe = ((IsNormalized()) ? this : NormalizeL(aRegistry));
+
+    if (!(dynamic_cast<CAndCompositeAssertion*>(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();
+        	nPOLICY->AddTerm(normalizedMe->IntersectL(target->GetTerms()[0], NULL));
+        	return nPOLICY;
+        }
+
+        case ECompositeXorType: 
+        {
+        	CXorCompositeAssertion* nXOR = CXorCompositeAssertion::NewL();
+        	RPointerArray<MAssertion> terms = target->GetTerms();
+
+            TInt termCount = terms.Count();
+
+           	for (TInt i = 0; i< termCount; i++)
+        	{
+        		MAssertion* asser = normalizedMe->IntersectL(terms[i]);
+
+        		if (asser->Type() == ECompositeAndType) 
+        		{
+        			nXOR->AddTerm(asser);
+        		}
+        		else
+        		{
+        		    DeleteAssertion(asser);
+        		}
+        		
+        	}
+        	return nXOR;
+        }
+
+        case ECompositeAndType: 
+        {
+        	RPolicyTerms PRIMITIVES_A = ((normalizedMe->Size() > target->Size()) ? normalizedMe->GetTerms() : target->GetTerms());
+        	RPolicyTerms PRIMITIVES_B = ((normalizedMe->Size() > target->Size()) ? target->GetTerms() : normalizedMe->GetTerms());
+
+        	CPrimitiveAssertion* PRIMITIVE_A = NULL;
+        	CPrimitiveAssertion* PRIMITIVE_B = NULL;
+
+        	for (int i = 0; i < PRIMITIVES_A.Count(); i++) 
+        	{
+        		PRIMITIVE_A = (CPrimitiveAssertion*) PRIMITIVES_A[i];
+
+        		TBool flag = false;
+
+        		for (int j = 0; j < PRIMITIVES_B.Count(); j++) 
+        		{
+        			PRIMITIVE_B = (CPrimitiveAssertion*) PRIMITIVES_B[j];
+
+        			if (PRIMITIVE_A->Name().Compare(PRIMITIVE_B->Name()) == 0) 
+        			{
+        				flag = true;
+        				break;
+        			}
+
+        		}
+
+        		if (!flag) 
+        		{
+        			return CXorCompositeAssertion::NewL();
+        		}
+
+        		MAssertion* a = PRIMITIVE_A->IntersectL(PRIMITIVE_B);
+
+        		if (dynamic_cast<CXorCompositeAssertion*>(a)) 
+        		{
+        		    DeleteAssertion(a);
+        			return CXorCompositeAssertion::NewL();
+        		}
+                else
+                {
+                    DeleteAssertion(a);
+                }
+        		
+        	}
+        	CAndCompositeAssertion* result = CAndCompositeAssertion::NewL();
+        	result->AddTermsCopyL(PRIMITIVES_A);
+        	result->AddTermsCopyL(PRIMITIVES_B);
+        	return result;
+        }
+
+        case EPrimitiveType: 
+        {
+        	CQName* name = ((CPrimitiveAssertion*) target)->QName();
+        	TBool isMatch = false;
+
+        	CQName* targetName = NULL;
+        	RPolicyTerms terms = normalizedMe->GetTerms();
+            for (TInt j = 0; j < terms.Count(); j++) 
+        	{
+        		targetName = ((CPrimitiveAssertion*) terms[j])->QName();
+
+        		if (name->Uri().Compare(targetName->Uri()) == 0) 
+        		{
+        			isMatch = true;
+        			break;
+        		}
+        	}
+
+        	if (isMatch) {
+        		CAndCompositeAssertion* nAND = CAndCompositeAssertion::NewL();
+        	    RPolicyTerms tgtTerm = normalizedMe->GetTerms();
+        		nAND->AddTerms(tgtTerm);
+        		nAND->AddTerm(target);
+        		return nAND;
+        	}
+
+        	return CXorCompositeAssertion::NewL();
+        }
+
+        default: 
+        {
+        }
+
+    }
+    return NULL;    
+}
+MAssertion*	CAndCompositeAssertion::MergeL(MAssertion* aAssertion, CPolicyRegistry* aRegistry)
+{
+	MAssertion* normalizedMe = (IsNormalized()) ? this : NormalizeL(aRegistry);
+
+	if (!(dynamic_cast<CAndCompositeAssertion*>(normalizedMe))) 
+	{
+		return normalizedMe->MergeL(aAssertion, aRegistry);
+	}
+
+	MAssertion* target = (aAssertion->IsNormalized()) ? aAssertion : aAssertion->NormalizeL(aRegistry);
+
+	switch (target->Type()) 
+	{
+
+    	case ECompositePolicyType: 
+    	{
+    		CPolicyAssertion* nPOLICY = CPolicyAssertion::NewL();
+    		RPolicyTerms xTerms = target->GetTerms();
+    		if(xTerms.Count() > 0)
+    		{
+    		    CXorCompositeAssertion* term = (CXorCompositeAssertion*)xTerms[0];		    
+    		    nPOLICY->AddTerm(normalizedMe->MergeL(term));		   
+    		}		
+    		return nPOLICY;
+    	}
+
+    	case ECompositeXorType: 
+    	{
+
+    		CXorCompositeAssertion* nXOR = CXorCompositeAssertion::NewL();
+            RPolicyTerms xTerms = target->GetTerms();
+    		for (TInt i=0; i< xTerms.Count(); i++)
+    		{
+    			CAndCompositeAssertion* AND = (CAndCompositeAssertion*) xTerms[i];
+    			nXOR->AddTerm(normalizedMe->MergeL(AND));
+    		}
+
+    		return nXOR;
+    	}
+
+    	case ECompositeAndType: 
+    	{
+    		CAndCompositeAssertion* nAND = CAndCompositeAssertion::NewL();
+            RPolicyTerms terms = normalizedMe->GetTerms();
+    		nAND->AddTermsCopyL(terms);
+    		RPolicyTerms targeterms = target->GetTerms();
+    		nAND->AddTermsCopyL(targeterms);
+
+    		return nAND;
+    	}
+
+    	case EPrimitiveType: 
+    	{
+    		CAndCompositeAssertion* nAND = CAndCompositeAssertion::NewL();
+            RPolicyTerms terms = normalizedMe->GetTerms();
+    		nAND->AddTermsCopyL(terms);
+    		nAND->AddTermCopyL(target);
+
+    		return nAND;
+    	}
+
+	}
+    
+    return NULL;	
+}
+