--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/policymanagement/policyengine/policyengineserver/src/ElementBase.cpp Thu Dec 17 09:07:52 2009 +0200
@@ -0,0 +1,1046 @@
+/*
+* Copyright (c) 2000 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: Implementation of policymanagement components
+*
+*/
+
+
+// INCLUDES
+
+#include "ElementBase.h"
+#include "PolicyStorage.h"
+#include "PolicyParser.h"
+#include "XACMLconstants.h"
+#include "elements.h"
+#include "ErrorCodes.h"
+#include "debug.h"
+#include "PolicyEngineServer.h"
+
+#include <e32std.h>
+
+// CONSTANTS
+// MACROS
+// DATA TYPES
+// FUNCTION PROTOTYPES
+// FORWARD DECLARATIONS
+// CLASS DECLARATION
+
+// ----------------------------------------------------------------------------------------
+// ElementHelper namespace contains utility functions for element handling
+// ----------------------------------------------------------------------------------------
+
+namespace ElementHelper
+{
+ // ----------------------------------------------------------------------------------------
+ // ElementHelper::DecodeEmptyElement
+ // ----------------------------------------------------------------------------------------
+
+ HBufC8 * DecodeEmptyElement( const TDesC8& aElementName)
+ {
+ //needed extra space in description
+ const TInt KExtraSpace = 4;
+
+ //create cbuf (return value)
+ HBufC8 * hbuf = HBufC8::NewL( aElementName.Length() + KExtraSpace);
+ TPtr8 ptr = hbuf->Des();
+
+ //append empty element format
+ ptr.Append('<');
+ ptr.Append( aElementName);
+ ptr.Append(_L(" />"));
+
+ return hbuf;
+ }
+
+ // ----------------------------------------------------------------------------------------
+ // ElementHelper::CreateNewElementL Create new element, element type is identified by aElementId
+ // ----------------------------------------------------------------------------------------
+
+ CElementBase * CreateNewElementL( const TUint32& aElementId)
+ {
+ //decode element type
+ TInt type = aElementId & 0xff;
+ CElementBase * element = 0;
+
+ //create empty element
+ switch ( type)
+ {
+ case EPolicySet:
+ element = CPolicySet::NewL();
+ break;
+ case EPolicy:
+ element = CPolicy::NewL();
+ break;
+ case ETarget:
+ element = CTarget::NewL();
+ break;
+ case ERule:
+ element = CRule::NewL();
+ break;
+ case ESubjects:
+ element = CSubjects::NewL();
+ break;
+ case ESubject:
+ element = CSubject::NewL();
+ break;
+ case ESubjectAttributeDesignator:
+ element = CSubjectAttributeDesignator::NewL();
+ break;
+ case ESubjectMatch:
+ element = CMatchObject::NewL( ESubjectMatch);
+ break;
+ case EActions:
+ element = CActions::NewL();
+ break;
+ case EAction:
+ element = CAction::NewL();
+ break;
+ case EActionAttributeDesignator:
+ element = CActionAttributeDesignator::NewL();
+ break;
+ case EActionMatch:
+ element = CMatchObject::NewL( EActionMatch);
+ break;
+ case EResources:
+ element = CResources::NewL();
+ break;
+ case EResource:
+ element = CResource::NewL();
+ break;
+ case EResourceAttributeDesignator:
+ element = CResourceAttributeDesignator::NewL();
+ break;
+ case EResourceMatch:
+ element = CMatchObject::NewL( EResourceMatch);
+ break;
+ case EEnvironments:
+ element = CEnvironment::NewL();
+ break;
+ case EEnvironment:
+ element = CEnvironment::NewL();
+ break;
+ case EEnvironmentAttributeDesignator:
+ element = CEnvironmentAttributeDesignator::NewL();
+ break;
+ case EEnvironmentMatch:
+ element = CMatchObject::NewL( EEnvironmentMatch);
+ break;
+ case EDescription:
+ element = CDescription::NewL();
+ break;
+ case ECondition:
+ element = CCondition::NewL();
+ break;
+ case EApply:
+ element = CApply::NewL();
+ break;
+ default:
+ User::Panic(PolicyExecutionPanic, KErrCorrupt);
+ break;
+ }
+
+ //set id and storage reference
+ element->SetId( aElementId);
+
+ return element;
+ }
+
+ // ----------------------------------------------------------------------------------------
+ // ElementHelper::CompareElements Compare function for RArray
+ // ----------------------------------------------------------------------------------------
+
+ TInt CompareElements( CElementBase* const& aElement1, CElementBase* const& aElement2)
+ {
+ if ( aElement1->GetId() == aElement2->GetId()) return 0;
+ return ( aElement1->GetId() < aElement2->GetId() ? -1 : 1 );
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// CElementBase::CElementBase()
+// -----------------------------------------------------------------------------
+//
+
+CElementBase::CElementBase()
+ : iElementState( ENewElement), iSaveType( EOwnElement),
+ iCreateExternalId( EFalse), iExternalId( NULL), iParentId( 0), iElementId( 0),
+ iReferenceCount( KNotInElementCache)
+{
+}
+
+
+// -----------------------------------------------------------------------------
+// CElementBase::CElementBase()
+// -----------------------------------------------------------------------------
+//
+
+CElementBase::CElementBase( const TUint32& aElementId )
+ : iElementState( ENotLoaded), iSaveType( EOwnElement), iCreateExternalId( EFalse), iExternalId( NULL), iParentId( 0),
+ iElementId( aElementId), iReferenceCount( KNotInElementCache)
+{
+}
+
+
+
+// -----------------------------------------------------------------------------
+// CElementBase::~CElementBase()
+// -----------------------------------------------------------------------------
+//
+
+CElementBase::~CElementBase()
+{
+ //delete all containers in the element list
+ for (TInt i(0); i < iElements.Count(); i++)
+ {
+ TElementContainer * container = iElements[i];
+
+ //delete element only when it isn't in policy storage
+ if ( container->iDeleteWithElement)
+ {
+ delete container->iElement;
+ }
+
+ //allways delete container
+ delete container;
+ }
+
+ iElements.Close();
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::ElementType()
+// -----------------------------------------------------------------------------
+//
+
+TNativeElementTypes CElementBase::ElementType()
+{
+ return iElementType;
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::ElementType()
+// -----------------------------------------------------------------------------
+//
+TNativeElementTypes CElementBase::SubElementType( const TInt& aIndex, const TInt& aExpectedCount)
+{
+ //check that aIndex is valid
+ if ( aIndex >= iElements.Count())
+ {
+ return (TNativeElementTypes)KErrNotFound;
+ }
+
+ //Check also expected count if parameter is given (positive)
+ if ( aExpectedCount >= 0 && aExpectedCount != iElements.Count())
+ {
+ return (TNativeElementTypes)KErrNotFound;
+ }
+
+ //return type of element
+ return iElements[ aIndex]->iElement->ElementType();
+}
+
+
+// -----------------------------------------------------------------------------
+// CElementBase::SetId()
+// -----------------------------------------------------------------------------
+//
+
+void CElementBase::SetId( const TUint32& aElementId)
+{
+ iElementId = aElementId;
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::CreateId()
+// -----------------------------------------------------------------------------
+//
+
+void CElementBase::CreateIdL()
+{
+ //if element doesn't have id, get new id from policy storage
+ if ( iElementId == 0)
+ {
+ iElementId = CPolicyStorage::PolicyStorage()->CreateIdL( iElementType);
+ }
+
+ //create ids also for child elements
+/* for ( TInt i(0); i < iElements.Count(); i++)
+ {
+ TElementContainer * container = iElements[i];
+ container->iElement->CreateIds( aPolicyStorage);
+ }*/
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::GetId()
+// -----------------------------------------------------------------------------
+//
+
+TUint32 CElementBase::GetId() const
+{
+ return iElementId;
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::AddParentIdL()
+// -----------------------------------------------------------------------------
+//
+
+void CElementBase::AddParentIdL( TUint32 iMotherId)
+{
+ //parent id is saved only for rules, policysets and policies
+ if ( iElementType == ERule || iElementType == EPolicySet || iElementType == EPolicy )
+ {
+/* //create new parant element list if list doesn't exist
+ if ( !iParentElements )
+ {
+ iParentElements = new (ELeave) RIdList;
+ }
+
+ //add parent to list
+ iParentElements->AppendL( iMotherId);
+*/
+ iParentId = iMotherId;
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::CheckNewParentId()
+// -----------------------------------------------------------------------------
+//
+/*
+TBool CElementBase::CheckNewParentId( TUint32 iMotherId)
+{
+ if (!iParentElements)
+ {
+ return ETrue;
+ }
+
+ for ( TInt i = 0; i < iParentElements->Count(); i++)
+ {
+ if ( (*iParentElements)[i] == iMotherId)
+ {
+ return EFalse;
+ }
+ }
+
+ return ETrue;
+}*/
+
+// -----------------------------------------------------------------------------
+// CElementBase::DeleteElementL()
+// -----------------------------------------------------------------------------
+//
+
+void CElementBase::DeleteElementL()
+{
+ __ASSERT_ALWAYS ( iElementId || iSaveType == ESubElement, User::Panic(PolicyStoragePanic, KErrGeneral));
+
+ //if element is subelement which is saved part of parent element
+ if ( iSaveType == ESubElement) return;
+
+ //remove element
+ CPolicyStorage::PolicyStorage()->DeleteElementL( iElementId);
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::DeleteMarkRecursiveL()
+// -----------------------------------------------------------------------------
+//
+void CElementBase::DeleteMarkRecursiveL()
+{
+ iElementState = EDeletedEditableElement;
+
+ for ( TInt i(0); i < iElements.Count(); i++)
+ {
+ //get element from list, add parent and save it
+ CElementBase * element = iElements[i]->iElement;
+
+ //check and load element (to editable cache)
+ TElementReserver reserver( element);
+ CPolicyStorage::PolicyStorage()->CheckElementL( element);
+
+ element->DeleteMarkRecursiveL();
+
+ reserver.Release();
+ }
+}
+
+
+
+
+// -----------------------------------------------------------------------------
+// CElementBase::RemoveChild()
+// -----------------------------------------------------------------------------
+//
+
+TInt CElementBase::RemoveChild( const TUint32& aChildId)
+{
+ TInt err = KErrNotFound;
+
+ //delete also child elements
+ for ( TInt i(0); i < iElements.Count(); i++)
+ {
+ //get element from list, add parent and save it
+ TElementContainer * container = iElements[i];
+ __ASSERT_ALWAYS ( container, User::Panic(PolicyStoragePanic, KErrGeneral));
+
+ if ( container->iElement->iElementId == aChildId)
+ {
+ //delete container and remove it from child list
+ delete iElements[i];
+ iElements.Remove( i);
+ err = KErrNone;
+ break;
+ }
+ }
+
+ return err;
+}
+
+
+// -----------------------------------------------------------------------------
+// CElementBase::CreateExternalId()
+// -----------------------------------------------------------------------------
+//
+void CElementBase::CreateExternalId()
+{
+ iCreateExternalId = ETrue;
+}
+
+
+// -----------------------------------------------------------------------------
+// CElementBase::SaveElementL()
+// -----------------------------------------------------------------------------
+//
+
+TInt CElementBase::SaveElementL( TBool aRecursive)
+{
+
+
+ //check id
+ if ( (iElementId == 0 && iSaveType == EOwnElement )|| iCreateExternalId)
+ {
+ if ( iElementId == 0)
+ {
+ iElementId = CPolicyStorage::PolicyStorage()->CreateIdL( iElementType);
+ }
+ }
+
+ //if aResursive, make recursive save also for childs
+ if ( aRecursive )
+ {
+ for ( TInt i(0); i < iElements.Count(); i++)
+ {
+ //get element from list, add parent and save it
+ TElementContainer * container = iElements[i];
+ if ( iSaveType == EOwnElement)
+ {
+ container->iElement->AddParentIdL( GetId());
+ }
+ container->iElement->SaveElementL( ETrue);
+ }
+ }
+
+ TInt err(KErrNone);
+
+ //Save element, if element is subelement it is already saved by parent element
+ if ( iSaveType == EOwnElement)
+ {
+ //decode element, use id mode where only child id is saved to description
+ HBufC8 * description = DecodeElementL( ENative, EIdMode);
+ CleanupStack::PushL( description);
+
+ //id parent element is defined
+ if ( iParentId )
+ {
+ //create buffer for parent mapping
+ HBufC8 * temp = HBufC8::NewL( description->Length() + (KIdLength + 1));
+ TPtr8 ptr = temp->Des();
+
+ //add original description
+ ptr.Append( *description);
+
+ //and parent mapping
+ ptr.Append( KParentListStartMark);
+ ptr.AppendNum( iParentId);
+
+ //delete old description and push old in cleanup stack
+ CleanupStack::PopAndDestroy( description); //old description
+ CleanupStack::PushL( temp);
+ description = temp;
+ }
+
+ //write policy to database
+ CPolicyStorage::PolicyStorage()->SaveElementL( iElementId, description);
+
+ CleanupStack::PopAndDestroy( description);
+ }
+
+ return err;
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::SelectCorrectValue()
+// -----------------------------------------------------------------------------
+//
+
+const TDesC8& CElementBase::SelectCorrectValue( const TLanguageSelector &aLanguage, const TDesC8& aOriginalValue ) const
+{
+ if ( aLanguage == ENative )
+ {
+ return aOriginalValue;
+ }
+
+ return CPolicyParser::ConvertValues( ENative, aOriginalValue);
+}
+
+
+// -----------------------------------------------------------------------------
+// CElementBase::DecodeElementOrIdL()
+// -----------------------------------------------------------------------------
+//
+
+HBufC8 * CElementBase::DecodeElementOrIdL( const TLanguageSelector &aLanguage, CElementBase * aElement, const TDecodeMode &aMode)
+{
+ HBufC8 * buffer = NULL;
+
+ //if full mode, decode full element. In id mode only id list is decoded
+ if ( aMode == EFullMode)
+ {
+ buffer = aElement->DecodeElementL( aLanguage, EFullMode);
+ }
+ else
+ {
+ if ( aElement->iSaveType == ESubElement )
+ {
+ buffer = aElement->DecodeElementL( aLanguage, aMode);
+ }
+ else
+ {
+ buffer = aElement->DecodeIdL();
+ }
+ }
+
+
+ return buffer;
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::DecodeIdL()
+// -----------------------------------------------------------------------------
+//
+
+HBufC8 * CElementBase::DecodeIdL()
+{
+ //decoding format
+ _LIT8( DecodeFormat,"|%d");
+
+ //create buffer for id
+ const TInt KIdPtrLength = 10;
+ HBufC8 * hbuf = HBufC8::NewLC(KIdPtrLength);
+
+ //format it
+ hbuf->Des().Format( DecodeFormat, iElementId);
+
+ CleanupStack::Pop();
+ return hbuf;
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::AddToElementListL()
+// -----------------------------------------------------------------------------
+//
+
+void CElementBase::AddToElementListL( CElementBase * aElement, TBool aDeleteWithElement)
+{
+ //create new container for element
+ TElementContainer * container = new (ELeave) TElementContainer;
+
+
+ //fill container and apppend it to list
+ container->iElement = aElement;
+ container->iDeleteWithElement = aDeleteWithElement;
+
+ iElements.AppendL( container);
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::DescriptionL()
+// -----------------------------------------------------------------------------
+//
+
+HBufC8 * CElementBase::DescriptionL()
+{
+ //try find description element from element list
+ for (TInt i(0); i < iElements.Count(); i++)
+ {
+ TElementContainer * container = iElements[i];
+ //reserve element from storage
+ TElementReserver elementReserver( container->iElement);
+
+ if ( container->iElement->iElementType == EDescription )
+ {
+ //check element and read description
+ CPolicyStorage::PolicyStorage()->CheckElementL( container->iElement);
+ CDescription * description = (CDescription*) container->iElement;
+ elementReserver.Release();
+ return description->DescriptionText();
+ }
+
+ elementReserver.Release();
+ }
+
+ return NULL;
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::GetChildListLengthL()
+// -----------------------------------------------------------------------------
+//
+
+TInt CElementBase::GetChildListLengthL()
+{
+ TInt size = 0;
+
+ //policies, rules, policysets are elements which are shown external child list
+ for (TInt i(0); i < iElements.Count(); i++)
+ {
+ CElementBase * element = iElements[i]->iElement;
+ TElementReserver elementReserver( element);
+
+ if ( element->iElementType == ERule || element->iElementType == EPolicy ||
+ element->iElementType == EPolicySet )
+ {
+ //check element and read external id length
+ CPolicyStorage::PolicyStorage()->CheckElementL( element);
+ size += element->ExternalId()->Length() + 1;
+ }
+
+ elementReserver.Release();
+ }
+
+ return size;
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::GetChildListL()
+// -----------------------------------------------------------------------------
+//
+
+void CElementBase::GetChildListL( TDes8& aChilds)
+{
+ //policies, rules, policysets are elements which are shown external child list
+ for (TInt i(0); i < iElements.Count(); i++)
+ {
+ CElementBase * element = iElements[i]->iElement;
+ TElementReserver elementReserver( element);
+
+ //add child ids to one list one after one
+ if ( element->iElementType == ERule || element->iElementType == EPolicy ||
+ element->iElementType == EPolicySet )
+ {
+ CPolicyStorage::PolicyStorage()->CheckElementL( element);
+ aChilds.Append( *(element->ExternalId()));
+ aChilds.Append( KMessageDelimiterChar);
+ }
+
+ elementReserver.Release();
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::GetChildElementCountL()
+// -----------------------------------------------------------------------------
+//
+
+TInt CElementBase::GetChildElementCountL()
+{
+ TInt count(0);
+
+ //policies, rules, policysets are elements which are shown external child list
+ for (TInt i(0); i < iElements.Count(); i++)
+ {
+ CElementBase * element = iElements[i]->iElement;
+ TElementReserver elementReserver( element);
+
+ if ( element->iElementType == ERule || element->iElementType == EPolicy ||
+ element->iElementType == EPolicySet )
+ {
+ count++;
+ }
+ }
+
+ return count;
+}
+
+
+// -----------------------------------------------------------------------------
+// CElementBase::CheckAllElementsL()
+// -----------------------------------------------------------------------------
+//
+
+void CElementBase::CheckAllElementsL()
+{
+ //Make element check for all elements in contaneiner list
+ for (TInt i(0); i < iElements.Count(); i++)
+ {
+ CPolicyStorage::PolicyStorage()->CheckElementL( iElements[i]->iElement);
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::CheckAllElementsL()
+// -----------------------------------------------------------------------------
+//
+
+TInt CElementBase::ElementCount()
+{
+ return iElements.Count();
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::CheckAllElementsL()
+// -----------------------------------------------------------------------------
+//
+
+CElementBase * CElementBase::Element( TInt aIndex)
+{
+ return iElements[ aIndex]->iElement;
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::ReleaseElement()
+// -----------------------------------------------------------------------------
+//
+
+void CElementBase::ReleaseElement()
+{
+ //this operation is only for cache elements
+ if ( iReferenceCount == KNotInElementCache) return;
+
+ iReferenceCount--;
+
+// RDEBUG_3(_L("Policy Engine: Decrease element %d reference count (%d)"), iElementId, iReferenceCount);
+
+ //reference count must be equal or greater than zero
+ __ASSERT_ALWAYS ( iReferenceCount >= 0, User::Panic(PolicyStoragePanic, KErrGeneral));
+
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::ReserveElement()
+// -----------------------------------------------------------------------------
+//
+
+
+void CElementBase::ReserveElement()
+{
+ //this operation is only for cache elements
+ if ( iReferenceCount == KNotInElementCache) return;
+
+ iReferenceCount++;
+
+// RDEBUG_3(_L("Policy Engine: Increase element %d reference count (%d)"), iElementId, iReferenceCount);
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::Container()
+// -----------------------------------------------------------------------------
+//
+
+
+RElementContainer* CElementBase::Container()
+{
+ return &iElements;
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::IdentificateElement()
+// -----------------------------------------------------------------------------
+//
+
+
+TBool CElementBase::IdentificateElement( const TDesC8& aElementName )
+{
+ return (iElementName == aElementName);
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::AbsoluteTarget()
+// -----------------------------------------------------------------------------
+//
+/*
+
+void CElementBase::AbsoluteTargetL( TUnionTarget * target)
+{
+ //assert allways when element is not rule, policy or policyset
+ __ASSERT_ALWAYS ( iElementType == ERule || iElementType == EPolicySet || iElementType == EPolicy, User::Panic(PolicyStoragePanic, KErrGeneral));
+
+ //add target definitions to one target union from parent list, resolve absolute target for them
+ if ( iParentElements)
+ {
+ for ( TInt i(0); i < iParentElements->Count(); i++ )
+ {
+ //get element from storage and check it
+ CElementBase * element = iPolicyStorage->GetElementL( (*iParentElements)[i]);
+ TElementReserver elementReserver( element);
+
+ //no need for type check, bacause all parent elements are correct type
+ iPolicyStorage->CheckElementL( element);
+ element->AbsoluteTargetL( target);
+
+ elementReserver.Release();
+ }
+ }
+
+ //add element target to targer union
+ for (TInt i(0); i < iElements.Count(); i++)
+ {
+ CElementBase * element = iElements[i]->iElement;
+ TElementReserver elementReserver( element);
+
+ if ( element->iElementType == ETarget )
+ {
+ //add target definitions to one target union
+ iPolicyStorage->CheckElementL( element);
+ target->AddTargetElementsL( element);
+ }
+
+ elementReserver.Release();
+ }
+
+}
+*/
+// -----------------------------------------------------------------------------
+// CElementBase::AddAttributeL()
+// -----------------------------------------------------------------------------
+//
+
+
+void CElementBase::AddAttributeL( CPolicyParser *aParser, const TDesC8& aName, const TDesC8& /*aValue*/)
+{
+ //unexpected attribute
+ aParser->HandleErrorL( ParserErrors::UnexpectedAttribute, aName);
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::AddContentL()
+// -----------------------------------------------------------------------------
+//
+
+
+void CElementBase::AddContentL( CPolicyParser *aParser, const TDesC8& aName)
+{
+ //unexpected content
+ aParser->HandleErrorL( ParserErrors::UnexpectedContent, aName);
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::AddElementL()
+// -----------------------------------------------------------------------------
+//
+
+void CElementBase::AddElementL( CPolicyParser *aParser, CElementBase * /*aElement*/)
+{
+ //unexpected element
+ aParser->HandleErrorL( ParserErrors::UnexpectedElement, aParser->ActiveElementName());
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::Match()
+// -----------------------------------------------------------------------------
+//
+
+
+TMatchResponse CElementBase::MatchL( CPolicyProcessor* /*aPolicyProcessor*/)
+{
+ User::Panic(PolicyExecutionPanic, KErrCorrupt);
+ TMatchResponse response = EIndeterminate;
+ return response;
+}
+
+
+// -----------------------------------------------------------------------------
+// CElementBase::ApplyValueL()
+// -----------------------------------------------------------------------------
+//
+
+CAttributeValue* CElementBase::ApplyValueL( CPolicyProcessor* /*aPolicyProcessor*/)
+{
+ User::Panic(PolicyExecutionPanic, KErrCorrupt);
+ return NULL;
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::DecodeElementL()
+// -----------------------------------------------------------------------------
+//
+
+HBufC8 * CElementBase::DecodeElementL( const TLanguageSelector &/*aLanguage*/, const TDecodeMode &/*aMode*/ )
+{
+ User::Panic(PolicyExecutionPanic, KErrCorrupt);
+ return NULL;
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::AddIdElementL()
+// -----------------------------------------------------------------------------
+//
+
+void CElementBase::AddIdElementL( CElementBase * /*aElement*/)
+{
+ User::Panic(PolicyExecutionPanic, KErrCorrupt);
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::ValidElement()
+// -----------------------------------------------------------------------------
+//
+
+TBool CElementBase::ValidElement()
+{
+ User::Panic(PolicyExecutionPanic, KErrCorrupt);
+ return ETrue;
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::CheckAllElementsL()
+// -----------------------------------------------------------------------------
+//
+
+HBufC8 * CElementBase::ExternalId() const
+{
+ return iExternalId;
+}
+
+
+// -----------------------------------------------------------------------------
+// CElementBase::GetElementsListLengthL()
+// -----------------------------------------------------------------------------
+//
+
+TInt CElementBase::GetElementsListLengthL( TElementType aType )
+{
+ TInt size = 0;
+
+ if ( iExternalId &&
+ ((iElementType == ERule && aType == ERules ) ||
+ (iElementType == EPolicy && aType == EPolicies ) ||
+ (iElementType == EPolicySet && aType == EPolicySets )))
+ {
+ size = iExternalId->Length() + 1;
+ }
+
+ //policies, rules, policysets are elements which are shown external child list
+ for (TInt i(0); i < iElements.Count(); i++)
+ {
+ CElementBase * element = iElements[i]->iElement;
+ TElementReserver elementReserver( element);
+
+ if ( element->iElementType == ERule ||
+ element->iElementType == EPolicy ||
+ element->iElementType == EPolicySet )
+ {
+ //check element and read external id length
+ CPolicyStorage::PolicyStorage()->CheckElementL( element);
+ size += element->GetElementsListLengthL( aType);
+ }
+
+ elementReserver.Release();
+ }
+
+ return size;
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::GetElementsListL()
+// -----------------------------------------------------------------------------
+//
+
+void CElementBase::GetElementsListL( TElementType aType, TDes8& aChilds)
+{
+ if ( iExternalId &&
+ ((iElementType == ERule && aType == ERules ) ||
+ (iElementType == EPolicy && aType == EPolicies ) ||
+ (iElementType == EPolicySet && aType == EPolicySets )))
+ {
+ aChilds.Append( *iExternalId);
+ aChilds.Append( KMessageDelimiterChar);
+ }
+
+ //policies, rules, policysets are elements which are shown external child list
+ for (TInt i(0); i < iElements.Count(); i++)
+ {
+ CElementBase * element = iElements[i]->iElement;
+ TElementReserver elementReserver( element);
+
+ //add child ids to one list one after one
+ if ( element->iElementType == ERule ||
+ element->iElementType == EPolicy ||
+ element->iElementType == EPolicySet )
+ {
+ CPolicyStorage::PolicyStorage()->CheckElementL( element);
+ element->GetElementsListL( aType, aChilds);
+ }
+
+ elementReserver.Release();
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CElementBase::FindAttributesL()
+// -----------------------------------------------------------------------------
+//
+void CElementBase::FindAttributesL( TNativeElementTypes aAttributeType, RElementArray& aValuesList)
+{
+ if ( iElementType == aAttributeType)
+ {
+ aValuesList.AppendL( this);
+ }
+ else
+ {
+ for ( TInt i = 0; i < iElements.Count(); i++)
+ {
+ CElementBase * element = iElements[i]->iElement;
+ TNativeElementTypes type = element->ElementType();
+
+ if ( type == ERule ||
+ type == ETarget ||
+ type == EPolicy ||
+ type == EPolicySet ||
+ type == ESubject ||
+ type == ESubjects ||
+ type == EAction ||
+ type == EActions ||
+ type == EResource ||
+ type == EResources ||
+ type == EEnvironment ||
+ type == EEnvironment ||
+ type == ESubjectMatch ||
+ type == EActionMatch ||
+ type == EResourceMatch ||
+ type == EEnvironmentMatch )
+ {
+ TElementReserver reserve( element);
+ CPolicyStorage::PolicyStorage()->CheckElementL( element);
+
+ element->FindAttributesL( aAttributeType, aValuesList);
+
+ reserve.Release();
+ }
+ }
+ }
+}