diff -r 000000000000 -r 62f9d29f7211 webservices/wsstar/wsstarpolicy/src/xorcompositeassertion.cpp
--- /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;	    
+}