diff -r 000000000000 -r 62f9d29f7211 webservices/wsstar/wsstarpolicy/src/primitiveassertion.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsstar/wsstarpolicy/src/primitiveassertion.cpp	Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,704 @@
+/*
+* 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 "primitiveassertion.h"
+#include "policyassertion.h"
+#include "xorcompositeassertion.h"
+#include "andcompositeassertion.h"
+#include "wspolicyreader.h"
+#include "wspolicyutils.h"
+using namespace WSPolicy;
+
+CPrimitiveAssertion* CPrimitiveAssertion::NewL()
+{
+    CPrimitiveAssertion* pSelf = CPrimitiveAssertion::NewLC();
+    CleanupStack::Pop(pSelf);
+    return pSelf;
+    
+}
+CPrimitiveAssertion* CPrimitiveAssertion::NewLC()
+{
+     CPrimitiveAssertion* pSelf = new (ELeave) CPrimitiveAssertion();
+    CleanupStack::PushL(pSelf);
+    pSelf->ConstructL();
+    return pSelf;
+   
+}
+CPrimitiveAssertion* CPrimitiveAssertion::NewL(CPrimitiveAssertion* aValue)
+{
+    CPrimitiveAssertion* pSelf = CPrimitiveAssertion::NewLC(aValue);
+    CleanupStack::Pop(pSelf);
+    return pSelf;
+    
+}
+CPrimitiveAssertion* CPrimitiveAssertion::NewLC(CPrimitiveAssertion* aValue)
+{
+    CPrimitiveAssertion* pSelf = new (ELeave) CPrimitiveAssertion();
+    CleanupStack::PushL(pSelf);
+    pSelf->ConstructL(aValue);
+    return pSelf;
+}
+
+CPrimitiveAssertion* CPrimitiveAssertion::NewL(TDesC8& aName, TDesC8& aPrefix, TDesC8& aUri)
+{
+    CPrimitiveAssertion* pSelf = CPrimitiveAssertion::NewLC(aName,aPrefix, aUri);
+    CleanupStack::Pop(pSelf);
+    return pSelf;
+    
+}
+CPrimitiveAssertion* CPrimitiveAssertion::NewLC(TDesC8& aName, TDesC8& aPrefix, TDesC8& aUri)
+{
+     CPrimitiveAssertion* pSelf = new (ELeave) CPrimitiveAssertion();
+    CleanupStack::PushL(pSelf);
+    pSelf->ConstructL(aName, aPrefix, aUri);
+    return pSelf;
+   
+}
+
+CPrimitiveAssertion::~CPrimitiveAssertion()
+    {
+    delete iQname;//	QName qname;
+    if(iAttr != NULL)
+    	{
+        iAttr->Reset(); //Hashtable attributes = new Hashtable();
+        delete iAttr;
+    	}
+	delete iStrValue;
+    }
+
+CPrimitiveAssertion::CPrimitiveAssertion():
+iOwner(NULL), iIsOptional(EFalse),iStrValue(NULL)
+{
+    
+}
+void CPrimitiveAssertion::ConstructL()
+{
+    iAttr = new (ELeave) RAttributeMap(ETrue, ETrue);    
+}
+void CPrimitiveAssertion::ConstructL(CPrimitiveAssertion* aValue)
+{
+    CQName* temp = aValue->QName();
+    if(temp)
+    {
+        TPtrC8 name = temp->Name();
+        TPtrC8 prefix = temp->Prefix();
+        TPtrC8 uri = temp->Uri();
+        ConstructL(name, prefix,uri);
+    
+        SetAttributesL(aValue->Attributes());
+
+        TPtrC8 strval = aValue->StrValue();
+        iStrValue = strval.AllocL();
+        
+        RPolicyTerms terms = aValue->GetTerms();
+        
+        if(terms.Count() > 0)
+            AddTermsCopyL(terms);
+    }
+        
+}
+
+void CPrimitiveAssertion::ConstructL(TDesC8& aName, TDesC8& aPrefix, TDesC8& aUri)
+{
+    iQname = CQName::NewL(aName, aPrefix, aUri);
+    ConstructL();
+}
+MAssertion*	CPrimitiveAssertion::GetParent()
+{
+    return iOwner;   
+}
+RPolicyTerms& CPrimitiveAssertion::GetTerms()
+{  
+    return CAssertion::GetTerms();
+}
+TAssertionType CPrimitiveAssertion::Type()
+{
+  return EPrimitiveType;    
+}
+TBool CPrimitiveAssertion::HasParent()
+{
+    if(iOwner)    
+    return ETrue;
+    else
+    return EFalse;
+}
+TBool CPrimitiveAssertion::IsEmpty()
+{
+    if(Size() > 0)
+        return EFalse;
+    else
+        return ETrue;
+}
+void AppendAll(RPolicyTerms& aSource, RPolicyTerms& aDest)
+{
+    TInt count = aSource.Count();
+    if(count > 0)
+    {
+        for (TInt i = 0; i < count; i++)
+        {
+            MAssertion* term = aSource[i];
+            aDest.Append(term);
+        }
+    }
+}
+MAssertion* CPrimitiveAssertion::NormalizeL()
+{
+    return NormalizeL(NULL);
+}
+MAssertion* CPrimitiveAssertion::NormalizeL(CPolicyRegistry* aRegistry)
+{
+    if (IsNormalized()) 
+    {
+    	return this;
+    }
+
+    if (IsOptional()) 
+    {
+
+    	CXorCompositeAssertion* XOR = CXorCompositeAssertion::NewL();
+    	CAndCompositeAssertion* AND = CAndCompositeAssertion::NewL();
+
+    	CPrimitiveAssertion* PRIM = GetSelfWithoutTermsL();
+    	PRIM->RemoveAttribute(KWspOptinal);
+    	PRIM->SetOptional(false);
+    	RPolicyTerms terms1 = GetTerms();
+    	PRIM->SetTermsL(terms1);
+        
+    	AND->AddTerm(PRIM);
+    	XOR->AddTerm(AND);
+    	XOR->AddTerm(CAndCompositeAssertion::NewL());
+        
+        MAssertion* result = XOR->NormalizeL(aRegistry);
+        delete XOR;
+    	return result;
+
+    }
+    RPolicyTerms terms2 = GetTerms();
+    if (terms2.Count() == 0) 
+    {
+    	CPrimitiveAssertion* PRIM = GetSelfWithoutTermsL();
+    	PRIM->SetNormalized(true);
+    	return PRIM;
+    }
+
+    RPolicyTerms policyTerms;
+    RPolicyTerms nonPolicyTerms;
+    for(TInt i =0 ; i < terms2.Count(); i++) 
+    {
+    	MAssertion* term = terms2[i];
+
+    	if (dynamic_cast<CPolicyAssertion*>(term)) 
+    	{
+    		policyTerms.Append(term);
+
+    	} 
+    	else if (dynamic_cast<CPrimitiveAssertion*>(term)) 
+    	{
+    		nonPolicyTerms.Append(term);
+
+    	} 
+    	else 
+    	{
+    	}
+    }
+
+    if (policyTerms.Count() == 0) {
+    	CPrimitiveAssertion* PRIM = CPrimitiveAssertion::NewL(this);
+    	PRIM->SetNormalized(true);
+        policyTerms.Close();
+        nonPolicyTerms.Close();
+    	return PRIM;
+    }
+
+    CPolicyAssertion* policyTerm = CWSPolicyUtils::GetSinglePolicyL(policyTerms, aRegistry);
+    RPolicyTerms polTerms = policyTerm->GetTerms();
+    if(polTerms.Count() > 0)
+    {
+        MAssertion* xorTerm = polTerms[0];
+        RPolicyTerms ANDs = xorTerm->GetTerms();
+
+        if (ANDs.Count() == 0) 
+        {
+            delete policyTerm;
+            policyTerms.Close();
+            nonPolicyTerms.Close();
+        	return CXorCompositeAssertion::NewL();
+        }
+
+        if (ANDs.Count() == 1) 
+        {
+        //DONE
+            CAndCompositeAssertion* term = (CAndCompositeAssertion*) ANDs[0];
+        	term->AddTermsCopyL(nonPolicyTerms);
+        	CPrimitiveAssertion* PRIM = GetSelfWithoutTermsL();
+        	PRIM->AddTerm(policyTerm);
+            policyTerms.Close();
+            nonPolicyTerms.Close();
+        	return PRIM;
+        }
+
+        CPolicyAssertion* nPOLICY = CPolicyAssertion::NewL();
+        CXorCompositeAssertion* nXOR = CXorCompositeAssertion::NewL();
+        nPOLICY->AddTerm(nXOR);
+
+        RPolicyTerms list;
+
+        for (TInt j = 0; j < ANDs.Count(); j++) 
+        {
+        	CPrimitiveAssertion* nPRIM = GetSelfWithoutTermsL();
+        	
+            CAndCompositeAssertion* andTerm = (CAndCompositeAssertion*)ANDs[j];
+            RPolicyTerms terms3 = andTerm->GetTerms();
+        	AppendAll(terms3, list);
+
+        	if (nonPolicyTerms.Count() > 0) 
+        	{
+        		AppendAll(nonPolicyTerms, list);
+        	}
+        	CPolicyAssertion* pol = GetSinglePolicyL(list);
+        	nPRIM->AddTerm(pol);
+        	
+        	CAndCompositeAssertion* AND = CAndCompositeAssertion::NewL();
+        	AND->AddTerm(nPRIM);
+        	nXOR->AddTerm(AND);
+        	list.Close();
+        }
+
+    	delete policyTerm;
+        policyTerms.Close();
+        nonPolicyTerms.Close();
+        
+        nPOLICY->SetNormalized(ETrue);
+        return nPOLICY;    
+    }
+    
+    return NULL;    
+}
+MAssertion* CPrimitiveAssertion::IntersectL(MAssertion* aAssertion)
+{
+    return IntersectL(aAssertion, NULL); 
+}
+MAssertion* CPrimitiveAssertion::IntersectL(MAssertion* aAssertion, CPolicyRegistry* aRegistry)
+{
+	MAssertion* normalizedMe = (IsNormalized()) ? this : NormalizeL(aRegistry);
+
+	if (!(dynamic_cast<CPrimitiveAssertion*>(normalizedMe))) 
+	{
+		return normalizedMe->IntersectL(aAssertion, aRegistry);
+	}
+
+	MAssertion* target = (aAssertion->IsNormalized()) ? aAssertion : aAssertion->NormalizeL(aRegistry);
+
+	// Am not a primitive assertion anymore ..
+	if (!(dynamic_cast<CPrimitiveAssertion*>(aAssertion))) 
+	{
+		return normalizedMe->IntersectL(aAssertion, aRegistry);
+	}
+
+	// argument is not primitive type ..
+	if (!(dynamic_cast<CPrimitiveAssertion*>(target))) 
+	{
+		return target->IntersectL(normalizedMe, aRegistry);
+	}
+
+	CPrimitiveAssertion* arg = (CPrimitiveAssertion*) target;
+	CPrimitiveAssertion* self = (CPrimitiveAssertion*) normalizedMe;
+
+	if (!self->Name().Compare(arg->Name()) == 0) 
+	{
+		return CXorCompositeAssertion::NewL(); // no bahaviour is admisible
+	}
+
+	if (self->GetTerms().Count() == 0 && arg->GetTerms().Count() == 0) 
+	{
+		CAndCompositeAssertion* assertion2 = CAndCompositeAssertion::NewL();
+		assertion2->AddTermCopyL(self);
+		assertion2->AddTermCopyL(arg);
+		return assertion2;
+	}
+
+	if (self->GetTerms().Count() == 0 || arg->GetTerms().Count() == 0) 
+	{
+		return CXorCompositeAssertion::NewL(); // no
+	}
+
+	RPolicyTerms argChildTerms;
+	TBool closeArrayarg = EFalse;
+	if (dynamic_cast<CPolicyAssertion*>(arg->GetTerms()[0])) 
+	{
+		CWSPolicyUtils::GetPrimTermsListL((CPolicyAssertion*) arg->GetTerms()[0], argChildTerms);
+		closeArrayarg = ETrue;
+	}
+	else 
+	{
+		argChildTerms = arg->GetTerms();
+	}
+
+	RPolicyTerms selfChildTerms;
+	TBool closeArrayself = EFalse;
+	if (dynamic_cast<CPolicyAssertion*>(self->GetTerms()[0])) 
+	{
+		CWSPolicyUtils::GetPrimTermsListL((CPolicyAssertion*) self->GetTerms()[0], selfChildTerms);
+		closeArrayself = ETrue;
+	} 
+	else 
+	{
+		selfChildTerms = self->GetTerms();
+	}
+
+	///////////////////////////////////////////////////////////////////////
+	///////////////////////////////////////////////////////////////////////
+
+	CPrimitiveAssertion* PRIMITIVE_A = NULL;
+	CPrimitiveAssertion* PRIMITIVE_B = NULL;
+	RPolicyTerms primListA, primListB;
+
+	if (selfChildTerms.Count() > argChildTerms.Count()) {
+		primListA = selfChildTerms;
+		primListB = argChildTerms;
+	} else {
+		primListA = argChildTerms;
+		primListB = selfChildTerms;
+	}
+
+    for (TInt i = 0 ; i < primListA.Count(); i++)
+    {
+		PRIMITIVE_A = (CPrimitiveAssertion*) primListA[i];
+
+		TBool found = EFalse;
+        for (TInt j = 0 ; j < primListB.Count(); j++)
+        {
+			PRIMITIVE_B = (CPrimitiveAssertion*) primListB[j];
+			if (PRIMITIVE_A->Name().Compare(PRIMITIVE_B->Name()) == 0)
+			{
+				found = ETrue;
+				break;
+			}
+		}
+
+		if (!found) 
+		{
+		    if(closeArrayarg)
+		        argChildTerms.Close();
+		    if(closeArrayself)
+		        selfChildTerms.Close();
+		    
+			return CXorCompositeAssertion::NewL();
+		}
+
+        MAssertion* assert = PRIMITIVE_A->IntersectL(PRIMITIVE_B);
+		if (dynamic_cast<CXorCompositeAssertion*>(assert)) 
+		{
+		    if(closeArrayarg)
+		        argChildTerms.Close();
+		    if(closeArrayself)
+		        selfChildTerms.Close();
+		
+		    DeleteAssertion(assert);
+			return CXorCompositeAssertion::NewL();
+		}
+		else
+		{
+		    DeleteAssertion(assert);
+		}
+	}
+
+	CAndCompositeAssertion* andCompositeAssertion = CAndCompositeAssertion::NewL();
+	andCompositeAssertion->AddTermCopyL(arg);
+	andCompositeAssertion->AddTermCopyL(self);
+
+		    if(closeArrayarg)
+		        argChildTerms.Close();
+		    if(closeArrayself)
+		        selfChildTerms.Close();
+		    
+	return andCompositeAssertion;
+    
+}
+MAssertion* CPrimitiveAssertion::MergeL(MAssertion* aAssertion)
+{
+    return MergeL(aAssertion, NULL);
+}
+MAssertion* CPrimitiveAssertion::MergeL(MAssertion* aAssertion, CPolicyRegistry* aRegistry)
+{
+	MAssertion* normalizedMe = (IsNormalized()) ? this : NormalizeL(aRegistry);
+
+	if (!(dynamic_cast<CPrimitiveAssertion*>(normalizedMe))) 
+	{
+		return normalizedMe->MergeL(aAssertion, aRegistry);
+	}
+
+	MAssertion* target = (aAssertion->IsNormalized()) ? aAssertion : aAssertion->NormalizeL(aRegistry);
+
+	if (!(dynamic_cast<CPrimitiveAssertion*>(target))) 
+	{
+		return target->MergeL(normalizedMe, aRegistry);
+	}
+
+	/*
+	 * both self and the argument are primitive assertions. Hence both
+	 * should be wrapped in an AndCompositeType
+	 */
+	CAndCompositeAssertion* AND = CAndCompositeAssertion::NewL();
+	AND->AddTermCopyL(target);
+	AND->AddTermCopyL(normalizedMe);
+	return AND;
+    
+}
+TBool CPrimitiveAssertion::Remove(MAssertion* aAssertion)
+{
+    if(aAssertion)
+    {
+        CAssertion::Remove(aAssertion);
+    }
+    return ETrue;
+    
+}
+TInt CPrimitiveAssertion::Size()
+{
+    return CAssertion::Size();
+}
+
+
+TInt CPrimitiveAssertion::SetTermsL(RPolicyTerms& aTerms)
+{
+		this->AddTermsCopyL(aTerms);
+		return KErrNone;    
+}
+void  CPrimitiveAssertion::AddAttributeL(TDesC8& aQname, TDesC8& aValue)
+{
+    TInt indx = iAttr->Find(aQname);
+    if(indx == KErrNotFound)
+    {
+        iAttr->Append(aQname.AllocL(),aValue.AllocL());        
+    }
+    else
+    {
+        iAttr->UpdateValue(aQname.AllocL(),aValue.AllocL());    
+    }
+}
+TPtrC8 CPrimitiveAssertion::GetAttributeValue(const TDesC8& aQname)
+{
+    TInt indx = iAttr->Find(aQname);
+    if(indx != KErrNotFound)
+    {
+        const TDesC8* value =  iAttr->ValueAt(indx);
+        return *value; //->Ptr();
+    }
+    return KNullDesC8();
+}
+RAttributeMap& CPrimitiveAssertion::Attributes()
+{
+//    aAttributes.Copy(iAttr);
+return *iAttr;
+}
+TInt CPrimitiveAssertion::SetAttributesL(RAttributeMap& aAttributes)
+{
+ 
+ TInt count = aAttributes.Count();
+ for (TInt i=0; i< count; i++)   
+ {
+    const TDesC8* name = aAttributes.KeyAt(i);
+    const TDesC8* value = aAttributes.ValueAt(i);
+    HBufC8* tt = name->AllocL();
+    HBufC8* tt2 = value->AllocL();
+    TPtrC8 namePtr = tt->Des();
+    TPtrC8 valPtr = tt2->Des();
+    AddAttributeL(namePtr, valPtr);
+    delete tt;
+    delete tt2;
+ }
+    return KErrNone;
+}
+TInt  CPrimitiveAssertion::RemoveAttribute(const TDesC8& aQname)
+{
+    TInt indx = iAttr->Find(aQname);
+    if(indx != KErrNotFound)
+    {
+        iAttr->RemoveByKey(aQname);
+        return KErrNone;
+    }
+    return KErrNotFound;
+}
+
+CQName* CPrimitiveAssertion::QName()
+{   if(iQname)
+        return iQname;
+    else
+        return NULL;
+}
+TPtrC8 CPrimitiveAssertion::Name()
+{   if(iQname)
+    return iQname->QName();
+else
+    return KNullDesC8();
+}
+TPtrC8 CPrimitiveAssertion::StrValue()
+{
+    if(iStrValue)
+    return iStrValue->Des();
+    else
+    return KNullDesC8();
+}
+void CPrimitiveAssertion::SetStrValueL(TDesC8& aStrValue)
+{
+    if(aStrValue.Length() > 0)
+        iStrValue = aStrValue.AllocL();     
+}
+TAny* CPrimitiveAssertion::Value()
+{
+  return NULL;
+}
+
+TBool CPrimitiveAssertion::IsOptional()
+{
+    return iIsOptional;    
+}
+TInt CPrimitiveAssertion::SetOptional(TBool aOptional)
+{
+    iIsOptional = aOptional; 
+    return KErrNone; 
+}
+
+CPolicyAssertion* CPrimitiveAssertion::GetSinglePolicyL(RPolicyTerms aChildTerms)
+{
+
+		CPolicyAssertion* policy = CPolicyAssertion::NewL();
+		CXorCompositeAssertion* pXor = CXorCompositeAssertion::NewL();
+		CAndCompositeAssertion* pAnd = CAndCompositeAssertion::NewL();
+		pAnd->AddTermsCopyL(aChildTerms);
+		pXor->AddTerm(pAnd);
+		policy->AddTerm(pXor);
+		return policy;
+
+}
+
+TBool CPrimitiveAssertion::IsEmptyPolicy(CPolicyAssertion* aPolicy) 
+{
+
+        RPolicyTerms terms = aPolicy->GetTerms();
+        if(terms.Count() > 0)
+        {
+   	    	CXorCompositeAssertion* xorTerm = (CXorCompositeAssertion* )terms[0];
+    		return xorTerm->IsEmpty();
+        }
+        else
+            return EFalse;
+
+}
+
+RPolicyTerms CPrimitiveAssertion::GetTerms(CPolicyAssertion* aPolicy) 
+{
+
+    RPolicyTerms terms1 = aPolicy->GetTerms();
+    if(terms1.Count() > 0)
+    {
+        CXorCompositeAssertion* xorTerm = (CXorCompositeAssertion*)terms1[0];
+        if(xorTerm)
+        {
+            RPolicyTerms terms2 = xorTerm->GetTerms();
+            if(terms2.Count() > 0)
+            {
+                CAndCompositeAssertion* andTerm= (CAndCompositeAssertion*) terms2[0];
+                if(andTerm)
+                    return andTerm->GetTerms();
+            }
+        }
+    }
+    RPolicyTerms empty_terms;
+    return empty_terms;
+}
+
+CPrimitiveAssertion* CPrimitiveAssertion::GetSelfWithoutTermsL() 
+{
+    TPtrC8 name = iQname->Name();
+    TPtrC8 prefix = iQname->Prefix();
+    TPtrC8 uri = iQname->Uri();
+    
+	CPrimitiveAssertion* prim = CPrimitiveAssertion::NewL(name, prefix, uri);
+	prim->SetAttributesL(*iAttr);
+	TPtrC8 strval = StrValue();
+	prim->SetStrValueL(strval);
+	return prim;
+}
+
+
+CQName* CQName::NewL(TDesC8& aName, TDesC8& aPrefix, TDesC8& aUri)
+{
+    CQName* pSelf = CQName::NewLC(aName, aPrefix, aUri);
+    CleanupStack::Pop(pSelf);
+    return pSelf;
+    
+}
+CQName* CQName::NewLC(TDesC8& aName, TDesC8& aPrefix, TDesC8& aUri)
+{
+    CQName* pSelf = new (ELeave) CQName();
+    CleanupStack::PushL(pSelf);
+    pSelf->ConstructL(aName, aPrefix, aUri);
+    return pSelf;
+   
+}
+CQName::~CQName()
+{
+    delete iName;
+    delete iQName;
+    delete iPrefix;
+    delete iUri;	
+}
+TPtrC8 CQName::Name()
+{
+    return iName->Des();
+}
+TPtrC8 CQName::QName()
+{
+    return iQName->Des();
+}
+TPtrC8 CQName::Prefix()
+{
+    return iPrefix->Des();
+}
+TPtrC8 CQName::Uri()
+{
+    return iUri->Des();
+}
+CQName::CQName()
+{
+    
+}
+
+void CQName::ConstructL(TDesC8& aName, TDesC8& aPrefix, TDesC8& aUri)
+    {
+	_LIT8(KColon, ":"); 
+    iName = aName.AllocL();
+    iPrefix = aPrefix.AllocL();
+    iUri = aUri.AllocL();
+    iQName = HBufC8::NewL( aPrefix.Length() + KColon().Length() + aName.Length() );
+    TPtr8 qname = iQName->Des();
+    qname.Append( aPrefix );
+    qname.Append( KColon );
+    qname.Append( aName );
+    }
+// End of File
+
+