--- /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
+
+