--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsstar/wsstarpolicy/src/assertion.cpp Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,283 @@
+/*
+* 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 "assertion.h"
+#include "andcompositeassertion.h"
+#include "xorcompositeassertion.h"
+#include "wspolicywriter.h"
+#include "policyreferenceassertion.h"
+#include "sendebug.h" // internal Utils\inc - logging MACROs
+
+CAssertion* CAssertion::NewL()
+{
+ CAssertion* pSelf = CAssertion::NewLC();
+ CleanupStack::Pop(pSelf);
+ return pSelf;
+
+}
+CAssertion* CAssertion::NewLC()
+{
+ CAssertion* pSelf = new (ELeave) CAssertion();
+ CleanupStack::PushL(pSelf);
+ pSelf->ConstructL();
+ return pSelf;
+}
+CAssertion::~CAssertion()
+{
+ if(iChildterms.Count() > 0)
+ {
+ for(TInt i=0; i< iChildterms.Count(); i++)
+ {
+ MAssertion* assert = iChildterms[i];
+ DeleteAssertion(assert);
+ }
+ }
+ iChildterms.Reset();
+}
+
+CAssertion::CAssertion() :
+iParent(NULL),
+iNormalized(EFalse)
+{
+}
+
+void CAssertion::ConstructL()
+{
+}
+
+void CAssertion::AddTerm(MAssertion* aAssertion)
+{
+ if(aAssertion)
+ {
+ iChildterms.Append(aAssertion);
+ }
+}
+
+void CAssertion::AddTerms(RPolicyTerms& aAssertions)
+{
+ for(TInt i = 0; i<aAssertions.Count(); i++ )
+ {
+ MAssertion* assertion = aAssertions[i];
+ AddTerm(assertion);
+ }
+}
+
+void CAssertion::AddTermCopyL(MAssertion* aAssertion)
+{
+ MAssertion* eleToAdd = NULL;
+ if (aAssertion->Type() == EPrimitiveType)
+ {
+
+ eleToAdd = CPrimitiveAssertion::NewL((CPrimitiveAssertion*)aAssertion);
+
+ }
+ else if (aAssertion->Type() == ECompositeXorType)
+ {
+ eleToAdd = CXorCompositeAssertion::NewL((CXorCompositeAssertion*)aAssertion);
+ }
+ else if (aAssertion->Type() == EPolicyReferenceType)
+ {
+ eleToAdd = CPolicyReferenceAssertion::NewL((CPolicyReferenceAssertion*)aAssertion);
+ }
+ else if (aAssertion->Type() == ECompositePolicyType)
+ {
+ eleToAdd = CPolicyAssertion::NewL((CPolicyAssertion*)aAssertion);
+
+ }
+ else if (aAssertion->Type() == ECompositeAndType)
+ {
+ eleToAdd = CAndCompositeAssertion::NewL((CAndCompositeAssertion*)aAssertion);
+
+ }
+ else
+ {
+ }
+
+
+ if(eleToAdd)
+ {
+ iChildterms.Append(eleToAdd);
+ }
+
+}
+void CAssertion::AddTermsCopyL(RPolicyTerms& aAssertions)
+{
+ for(TInt i = 0; i<aAssertions.Count(); i++ )
+ {
+ MAssertion* assertion = aAssertions[i];
+ AddTermCopyL(assertion);
+ }
+
+}
+void CAssertion::MoveTermL(RPolicyTerms& /*aAssertions*/)
+{
+
+}
+void CAssertion::MoveTermsL(RPolicyTerms& aAssertions)
+{
+
+ for(TInt i = 0; i<aAssertions.Count(); i++ )
+ {
+ MAssertion* assertion = aAssertions[i];
+
+ if(assertion)
+ {
+ iChildterms.Append(assertion);
+ }
+
+ }
+ aAssertions.Reset();
+}
+
+MAssertion* CAssertion::GetParent()
+{
+ if(iParent)
+ return iParent;
+ else
+ return NULL;
+
+}
+RPolicyTerms& CAssertion::GetTerms()
+{
+ return iChildterms;
+}
+TBool CAssertion::HasParent()
+{
+ if(iParent)
+ return ETrue;
+ else
+ return EFalse;
+}
+MAssertion* CAssertion::IntersectL(MAssertion* aAssertion)
+{
+ return IntersectL(aAssertion, NULL);
+}
+TBool CAssertion::IsEmpty()
+{
+ if(iChildterms.Count() < 1)
+ return ETrue;
+ else
+ return EFalse;
+}
+TBool CAssertion::IsNormalized()
+{
+ return iNormalized;
+}
+MAssertion* CAssertion::MergeL(MAssertion* aAssertion)
+{
+ return MergeL(aAssertion, NULL);
+}
+MAssertion* CAssertion::NormalizeL()
+{
+ return NormalizeL(NULL);
+}
+TBool CAssertion::Remove(MAssertion* aAssertion)
+{
+ if(Size() > 0)
+ {
+ TInt indx = iChildterms.Find(aAssertion);
+ if(indx != KErrNotFound)
+ {
+ iChildterms.Remove(indx);
+ return ETrue;
+ }
+ }
+
+ return EFalse;
+}
+
+void CAssertion::SetNormalized(TBool aFlag)
+{
+ iNormalized = aFlag;
+ for (TInt i = 0; i < iChildterms.Count(); i++)
+ {
+ ((MAssertion*)iChildterms[i])->SetNormalized(aFlag);
+ }
+}
+void CAssertion::SetParent(MAssertion* aParent)
+{
+ iParent = aParent;
+}
+TInt CAssertion::Size()
+{
+ return iChildterms.Count();
+}
+
+MAssertion* CAssertion::IntersectL(MAssertion* /*aAssertion*/, CPolicyRegistry* /*aRegistry*/)
+{
+ return NULL;
+}
+MAssertion* CAssertion::MergeL(MAssertion* /*aAssertion*/, CPolicyRegistry* /*aRegistry*/)
+{
+ return NULL;
+}
+MAssertion* CAssertion::NormalizeL(CPolicyRegistry* /*aRegistry*/)
+{
+ return NULL;
+}
+
+TAssertionType CAssertion::Type()
+{
+ return EInvalidType;
+}
+TInt CAssertion::DeleteAssertion(MAssertion* aAssertion)
+{
+ if(aAssertion == NULL)
+ return KErrNone;
+
+
+ if (dynamic_cast<CPrimitiveAssertion*>(aAssertion))
+ {
+ CPrimitiveAssertion* ele = (CPrimitiveAssertion*)aAssertion;
+ delete ele;
+ ele = NULL;
+ }
+ else if (dynamic_cast<CXorCompositeAssertion*>(aAssertion))
+ {
+ CAssertion* ele = (CAssertion*)aAssertion;
+ delete ele;
+ ele = NULL;
+ }
+ else if (dynamic_cast<CPolicyReferenceAssertion*>(aAssertion))
+ {
+ CPolicyReferenceAssertion* ele = (CPolicyReferenceAssertion*)aAssertion;
+ delete ele;
+ ele = NULL;
+ }
+ else if (dynamic_cast<CPolicyAssertion*>(aAssertion))
+ {
+ CPolicyAssertion* ele = (CPolicyAssertion*)aAssertion;
+ delete ele;
+ ele = NULL;
+ }
+ else if (dynamic_cast<CAndCompositeAssertion*>(aAssertion))
+ {
+ CAssertion* ele = (CAssertion*)aAssertion;
+ delete ele;
+ ele = NULL;
+ }
+ return KErrNone;
+}
+
+// End of File