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