--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/policymanagement/policyengine/policyengineserver/src/Elements.cpp	Thu Dec 17 09:07:52 2009 +0200
@@ -0,0 +1,3468 @@
+/*
+* 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 "elements.h"
+#include "PolicyParser.h"
+#include "XACMLconstants.h"
+#include "DataTypes.h"
+#include "PolicyProcessor.h"
+#include "PolicyStorage.h"
+#include "ErrorCodes.h"
+#include "debug.h"
+
+
+
+// -----------------------------------------------------------------------------
+// RContentBuilder::RContentBuilder()
+// -----------------------------------------------------------------------------
+//
+
+RContentBuilder::RContentBuilder()
+	: RPointerArray<HBufC8>(), iSize(0)
+	{	
+	}
+
+// -----------------------------------------------------------------------------
+// RContentBuilder::AddContentL()
+// -----------------------------------------------------------------------------
+//
+
+void RContentBuilder::AddContentL( HBufC8 * aBuffer)
+	{
+	//Append buffer to pointer array
+	CleanupStack::PushL( aBuffer);
+	User::LeaveIfError( Append( aBuffer));
+	CleanupStack::Pop( aBuffer);
+	
+	//calculate new total size
+	iSize += aBuffer->Length();
+	}
+
+// -----------------------------------------------------------------------------
+// RContentBuilder::ContentL()
+// -----------------------------------------------------------------------------
+//
+
+HBufC8 * RContentBuilder::ContentL()
+	{
+	//create buffer for new content
+	HBufC8 * buffer = HBufC8::NewL( iSize);		
+	TPtr8 ptr = buffer->Des();
+	
+	//and append content of pointer array to buffer (step by step)
+	for ( TInt i(0); i < Count(); i++)
+		{
+		ptr.Append( *operator[]( i));
+		}
+	
+	//return buffer
+	return buffer;
+	}
+
+// -----------------------------------------------------------------------------
+// RContentBuilder::ContentLC()
+// -----------------------------------------------------------------------------
+//
+
+HBufC8 * RContentBuilder::ContentLC()
+	{
+	//create buffer and push it to cleanupstack
+	HBufC8 * buffer = ContentL();
+	CleanupStack::PushL( buffer);
+	
+	//return buffer
+	return buffer;
+	}
+
+// -----------------------------------------------------------------------------
+// RContentBuilder::Close()
+// -----------------------------------------------------------------------------
+//
+		
+void RContentBuilder::Close()
+	{
+	//destroy pointer array content
+	ResetAndDestroy();
+	
+	//and close array (parent class)
+	RPointerArray<HBufC8>::Close();
+	}
+
+
+
+// -----------------------------------------------------------------------------
+// CApply::CApply()
+// -----------------------------------------------------------------------------
+//
+
+CApply::CApply()
+	{	
+	iElementType = EApply;
+	iElementName.Set( PolicyLanguage::NativeLanguage::Expressions::Apply);
+
+	iSaveType = ESubElement;	
+	}
+
+// -----------------------------------------------------------------------------
+// CApply::~CApply()
+// -----------------------------------------------------------------------------
+//
+
+CApply::~CApply()
+{
+	delete iResponseValue;
+	delete iFunctionId;
+}
+
+// -----------------------------------------------------------------------------
+// CApply::NewL()
+// -----------------------------------------------------------------------------
+//
+		
+CApply * CApply::NewL()
+{
+	CApply * self = new (ELeave) CApply();
+	
+	CleanupStack::PushL( self);
+	self->ConstructL();
+	CleanupStack::Pop ( self);
+	
+	return self;
+}
+
+// -----------------------------------------------------------------------------
+// CApply::ConstructL()
+// -----------------------------------------------------------------------------
+//
+
+void CApply::ConstructL()
+{
+	iResponseValue = CAttributeValue::NewL();
+}
+
+// -----------------------------------------------------------------------------
+// CApply::IdentificateType()
+// -----------------------------------------------------------------------------
+//
+
+TBool CApply::IdentificateType( const TDesC8& aElementName)
+{
+	return ( aElementName == PolicyLanguage::NativeLanguage::Expressions::Apply);			
+}
+
+// -----------------------------------------------------------------------------
+// CApply::DecodeElementL
+// -----------------------------------------------------------------------------
+//
+
+HBufC8 * CApply::DecodeElementL( const  TLanguageSelector &aLanguage, const TDecodeMode &aMode)
+{
+	RDEBUG("PolicyEngineServer: Decode Apply element");
+
+	__ASSERT_ALWAYS ( iFunctionId, User::Panic(PolicyParserPanic, KErrCorrupt));
+	
+	//reserve all...
+	CheckAllElementsL();
+	TElementReserver reserver( Container());
+	
+	TInt size = 9;
+
+	size += 2 * PolicyLanguage::Expressions::Apply[ aLanguage].Length();
+
+	size += PolicyLanguage::Expressions::FunctionId[ aLanguage].Length();
+	
+	const TDesC8& functionId = SelectCorrectValue( aLanguage, *iFunctionId);
+	size += functionId.Length();
+
+	RContentBuilder builder;
+	CleanupClosePushL( builder);
+	
+	for ( TInt i(0); i < ElementCount(); i++)
+	{
+		CElementBase * element = Element(i);
+
+		if ( element->ElementType() == EApply )
+		{
+			builder.AddContentL( DecodeElementOrIdL( aLanguage, element, aMode));
+		}
+		else
+		{
+			builder.AddContentL( DecodeElementOrIdL( aLanguage, element, EFullMode));
+		}
+		
+	}	
+
+	HBufC8* applies	= builder.ContentL();
+	CleanupStack::PopAndDestroy( &builder);
+	CleanupStack::PushL( applies);
+
+	if (applies) size += applies->Length();
+	
+	HBufC8 * hbuf = HBufC8::NewLC( size);
+	TPtr8 ptr = hbuf->Des();
+	
+	ptr.Append('<');
+	ptr.Append(PolicyLanguage::Expressions::Apply[ aLanguage]);
+	ptr.Append(' ');
+	ptr.Append(PolicyLanguage::Expressions::FunctionId[ aLanguage]);
+	ptr.Append( _L8("=\""));
+	ptr.Append( functionId);
+	ptr.Append( _L8("\">"));
+	if (applies) ptr.Append(*applies);	
+	ptr.Append(_L8("</"));
+	ptr.Append(PolicyLanguage::Expressions::Apply[ aLanguage]);
+	ptr.Append('>');											   
+
+	CleanupStack::Pop( hbuf);
+	CleanupStack::PopAndDestroy( applies);
+	
+	reserver.Release();
+	
+
+	return hbuf;
+}
+
+// -----------------------------------------------------------------------------
+// CApply::AddAttributeL
+// -----------------------------------------------------------------------------
+//
+
+void CApply::AddAttributeL( CPolicyParser *aParser, const TDesC8& aName, const TDesC8& aValue)
+{
+	if ( aName == PolicyLanguage::NativeLanguage::Expressions::FunctionId)
+	{
+		aParser->HandleErrorL( iFunctionId , ParserErrors::UnexpectedAttribute, aName);	
+		iFunctionId = aValue.AllocL();
+		aParser->CheckFunctionIdL( EApply, *iFunctionId);
+	}
+	else
+	{
+		aParser->HandleErrorL( ParserErrors::UnexpectedAttribute, aName );	
+	}	
+}
+
+// -----------------------------------------------------------------------------
+// CApply::AddElementL
+// -----------------------------------------------------------------------------
+//
+
+void CApply::AddElementL( CPolicyParser *aParser, CElementBase * aElement)
+{
+	TNativeElementTypes type = aElement->ElementType();
+	
+	if ( type == EApply ||
+		 type == EAttributeValue ||
+		 type == ESubjectAttributeDesignator ||  
+		 type == EEnvironmentAttributeDesignator ||
+		 type == EResourceAttributeDesignator ||
+		 type == EActionAttributeDesignator ) 
+	{
+		AddToElementListL( aElement, ETrue);
+	}
+	else
+	{	
+		aParser->HandleErrorL( ParserErrors::UnexpectedElement, aParser->ActiveElementName());
+	}	
+}
+	
+// -----------------------------------------------------------------------------
+// CApply::AddIdElementL
+// -----------------------------------------------------------------------------
+//
+
+void CApply::AddIdElementL( CElementBase * aElement)
+{
+	__ASSERT_ALWAYS ( aElement, User::Panic(PolicyParserPanic, KErrCorrupt));
+	
+	AddToElementListL( aElement, EFalse);	
+}
+
+// -----------------------------------------------------------------------------
+// CApply::ValidElement
+// -----------------------------------------------------------------------------
+//
+
+TBool CApply::ValidElement()
+{
+	TBool returnValue = EFalse;
+
+	//function id is needed...
+	if ( iFunctionId)
+	{
+		returnValue = FunctionHelper::IsAcceptableParamsForFunction( *iFunctionId, Container());
+	}
+	
+	return returnValue;
+}
+
+// -----------------------------------------------------------------------------
+// CApply::ApplyValueL
+// -----------------------------------------------------------------------------
+//
+
+CAttributeValue * CApply::ApplyValueL( CPolicyProcessor* aPolicyProcessor)
+{
+#ifndef __POLICY_BASE_CREATOR_TOOL
+
+	//reserve elements
+	CheckAllElementsL();
+	TElementReserver reserver( Container());
+
+	//create parameter list add it cleanup stack
+	RParameterList params;
+	CleanupClosePushL( params);
+	
+	//search attributedesignators and apply elements
+	for (TInt i(0); i < ElementCount(); i++)
+	{
+		CElementBase * element = Element( i);
+		
+		switch ( element->ElementType())
+		{
+			case EApply:
+			{
+				//get parameter value from apply-element and append it parameter list
+				params.AppendL( ((CApply*)element)->ApplyValueL( aPolicyProcessor));
+			}
+			break;
+			case ESubjectAttributeDesignator:
+			case EEnvironmentAttributeDesignator:
+			case EResourceAttributeDesignator:
+			case EActionAttributeDesignator:
+			{
+				//get parameter value from request context (via attribute designators)			
+				CAttribute* attribute = ((CAttributeDesignator*) element)->GetAttributeFromRequestContext( aPolicyProcessor);
+				
+				if( attribute )
+					{
+					params.AppendL( attribute->AttributeValue());
+					}
+							
+				if ( !attribute) 
+					{
+					RDEBUG("PolicyEngineServer: PolicyProcessor: attribute not found");	
+
+				//	aPolicyProcessor->HandleErrorL( RequestErrors::MissingAttribute );
+					}
+			
+				//append value to paramer list
+				//params.AppendL( attribute->AttributeValue());
+			}
+			break;
+			case EAttributeValue:
+			{
+				//attribute value is valid parameter type
+				params.AppendL( (CAttributeValue*)element);
+			}
+			break;
+			default:
+				User::Panic( Panics::PolicyExecutionPanic, KErrAbort);
+			break;
+		}
+	}
+	
+	//execute function
+	aPolicyProcessor->FunctionL( *iFunctionId, params, iResponseValue );
+	
+	CleanupStack::PopAndDestroy( &params);	//params.Close()
+	reserver.Release();
+	
+	return iResponseValue;
+	
+#endif //#ifndef __POLICY_BASE_CREATOR_TOOL
+}
+
+
+
+// -----------------------------------------------------------------------------
+// CApply::ReturnDataType
+// -----------------------------------------------------------------------------
+//
+const TPtrC8 CApply::ReturnDataType()
+{
+	__ASSERT_ALWAYS ( iFunctionId, User::Panic(PolicyParserPanic, KErrCorrupt));
+
+	using namespace PolicyLanguage::NativeLanguage::Functions;
+
+	TPtrC8 ptr;
+
+	//set return data tpye
+	if ( *iFunctionId == FunctionStringEqualId ||
+		 *iFunctionId == FunctionBooleanEqualId ||
+		 
+		 *iFunctionId == FunctionOr ||
+		 *iFunctionId == FunctionAnd ||
+		 *iFunctionId == FunctionNot ||
+
+		 *iFunctionId == FunctionCertificatedSession ||
+		 *iFunctionId == FunctionUserAcceptCorpPolicy ||
+		 *iFunctionId == FunctionRuleTargetStructure )
+	{
+		ptr.Set( PolicyLanguage::NativeLanguage::AttributeValues::BooleanDataType);
+	}
+	
+	return ptr;
+}
+
+// -----------------------------------------------------------------------------
+// CCondition::CCondition
+// -----------------------------------------------------------------------------
+//
+
+CCondition::CCondition()
+{
+	iElementType = ECondition;
+	iElementName.Set( PolicyLanguage::NativeLanguage::Expressions::Condition);
+
+	iSaveType = ESubElement;
+}
+
+// -----------------------------------------------------------------------------
+// CCondition::~CCondition
+// -----------------------------------------------------------------------------
+//
+CCondition::~CCondition()
+{
+}
+		
+// -----------------------------------------------------------------------------
+// CCondition::NewL
+// -----------------------------------------------------------------------------
+//
+CCondition * CCondition::NewL()
+{
+	return new (ELeave) CCondition();
+}
+
+// -----------------------------------------------------------------------------
+// CCondition::IdentificateType
+// -----------------------------------------------------------------------------
+//
+TBool CCondition::IdentificateType( const TDesC8& aElementName)
+{
+	return ( aElementName == PolicyLanguage::NativeLanguage::Expressions::Condition);			
+}
+
+// -----------------------------------------------------------------------------
+// CCondition::DecodeElementL
+// -----------------------------------------------------------------------------
+//
+
+HBufC8 * CCondition::DecodeElementL( const  TLanguageSelector &aLanguage, const TDecodeMode &aMode)
+{
+	RDEBUG("PolicyEngineServer: Decode Condition element");
+
+
+	__ASSERT_ALWAYS ( iExpression, User::Panic(PolicyParserPanic, KErrCorrupt));
+
+	CheckAllElementsL();
+	TElementReserver reserver( Container());
+
+	TInt size(5);
+	TPtrC8 conditionPtr = PolicyLanguage::Expressions::Condition[ aLanguage];
+	size += 2 * conditionPtr.Length();
+	
+	HBufC8 * expression = DecodeElementOrIdL( aLanguage, iExpression, aMode);
+	CleanupStack::PushL( expression);
+	
+	size += expression->Length();
+	
+	HBufC8 * hbuf = HBufC8::NewLC( size);
+	TPtr8 ptr = hbuf->Des();
+	
+	ptr.Append( '<');
+	ptr.Append( conditionPtr);
+	ptr.Append( '>');
+	ptr.Append( *expression);
+	ptr.Append(_L8("</"));
+	ptr.Append( conditionPtr);
+	ptr.Append( '>');
+	
+	CleanupStack::Pop( hbuf);
+	CleanupStack::PopAndDestroy( expression);
+	
+	reserver.Release();
+	
+	return hbuf;
+}
+
+// -----------------------------------------------------------------------------
+// CCondition::AddElementL
+// -----------------------------------------------------------------------------
+//
+void CCondition::AddElementL( CPolicyParser *aParser, CElementBase * aElement)
+{
+	if ( aElement->ElementType() == EApply ) 
+	{
+		aParser->HandleErrorL( iExpression, ParserErrors::UnexpectedElement, aParser->ActiveElementName());	
+		AddToElementListL( aElement, ETrue);
+		iExpression = aElement;
+	}
+	else
+	{	
+		aParser->HandleErrorL( ParserErrors::UnexpectedElement, aParser->ActiveElementName());
+	}	
+}
+
+// -----------------------------------------------------------------------------
+// CCondition::AddIdElementL
+// -----------------------------------------------------------------------------
+//	
+void CCondition::AddIdElementL( CElementBase * aElement)
+{
+	__ASSERT_ALWAYS ( aElement, User::Panic(PolicyParserPanic, KErrCorrupt));
+	
+	iExpression = aElement;
+	AddToElementListL( aElement, EFalse);	
+}
+
+// -----------------------------------------------------------------------------
+// CCondition::ValidElement
+// -----------------------------------------------------------------------------
+//	
+
+TBool CCondition::ValidElement()
+{
+	TBool returnValue = EFalse;
+
+	if ( iExpression)
+	{
+		TPtrC8 dataType = ((CApply*) iExpression)->ReturnDataType();
+		
+		if ( dataType == PolicyLanguage::NativeLanguage::AttributeValues::BooleanDataType)
+		{
+			returnValue = ETrue;
+		}		
+	}
+
+	return returnValue;
+}
+
+
+// -----------------------------------------------------------------------------
+// CCondition::ConditionValuement
+// -----------------------------------------------------------------------------
+//¨
+
+#ifndef __POLICY_BASE_CREATOR_TOOL
+
+TMatchResponse CCondition::ConditionValueL( CPolicyProcessor* aPolicyProcessor)
+{
+	RDEBUG("PolicyEngineServer: Evaluate condition value - start");
+
+	__ASSERT_ALWAYS ( iExpression, User::Panic(PolicyParserPanic, KErrCorrupt));
+
+	//default response
+	TMatchResponse response = EIndeterminate;
+	
+	//check element
+	TElementReserver reserver( iExpression);
+	CPolicyStorage::PolicyStorage()->CheckElementL( iExpression);
+	
+	//apply-value from apply element
+	CAttributeValue * element = iExpression->ApplyValueL( aPolicyProcessor);
+	
+	//check that respose element is attribute...
+	if ( element->ElementType() == EAttributeValue )
+	{
+		CDataType * data = element->Data();
+		
+		//..attribute type should boolean
+		if ( data->DataType( ENative) == PolicyLanguage::NativeLanguage::AttributeValues::BooleanDataType)
+		{
+			if ( data->Value() == PolicyLanguage::NativeLanguage::AttributeValues::BooleanTrue)
+			{
+				RDEBUG("PolicyEngineServer: Condition value is TRUE");
+				response = EMatch;
+			}
+			else
+			{
+				RDEBUG("PolicyEngineServer: Condition value is FALSE");
+				response = EUnMatch;
+			}
+		}
+	}
+	
+	reserver.Release();
+	
+	//response...
+	RDEBUG("PolicyEngineServer: Evaluate condition value - end");
+	return response;
+}
+
+#endif // __POLICY_BASE_CREATOR_TOOL
+
+// -----------------------------------------------------------------------------
+// CPolicySet::CPolicySet
+// -----------------------------------------------------------------------------
+//
+CPolicySet::CPolicySet()
+{
+	iElementType = EPolicySet;
+	iElementName.Set( PolicyLanguage::NativeLanguage::PolicySet::PolicySet);
+}
+
+// -----------------------------------------------------------------------------
+// CPolicySet::~CPolicySet
+// -----------------------------------------------------------------------------
+//
+CPolicySet::~CPolicySet()
+{
+	delete iPolicySetId;
+	delete iPolicyCompiningAlg;
+}
+
+// -----------------------------------------------------------------------------
+// CPolicySet::NewL
+// -----------------------------------------------------------------------------
+//
+CPolicySet * CPolicySet::NewL()
+{
+	return new (ELeave) CPolicySet();
+}
+
+// -----------------------------------------------------------------------------
+// CPolicySet::IdentificateType
+// -----------------------------------------------------------------------------
+//
+TBool CPolicySet::IdentificateType( const TDesC8& aElementName)
+{
+	return ( aElementName == PolicyLanguage::NativeLanguage::PolicySet::PolicySet);			
+}
+
+// -----------------------------------------------------------------------------
+// CPolicySet::AddAttributeL
+// -----------------------------------------------------------------------------
+//
+void CPolicySet::AddAttributeL( CPolicyParser *aParser, const TDesC8& aName, const TDesC8& aValue)
+{
+	if ( aName == PolicyLanguage::NativeLanguage::PolicySet::PolicySetId)
+	{
+		aParser->HandleErrorL( iPolicySetId , ParserErrors::UnexpectedAttribute, aName);	
+		iPolicySetId = aValue.AllocL();
+		iExternalId = iPolicySetId;
+		aParser->CheckExternalIdL( iExternalId);
+	}
+	else	
+	if ( aName == PolicyLanguage::NativeLanguage::PolicySet::PolicyCombiningAlgId)
+	{
+		aParser->HandleErrorL( iPolicyCompiningAlg, ParserErrors::UnexpectedAttribute, aName);	
+		aParser->CheckCompiningAlgorithmsL( EPolicySet, aValue);
+		iPolicyCompiningAlg = aValue.AllocL();
+	}
+	else
+	{
+		aParser->HandleErrorL( ParserErrors::UnexpectedAttribute, aName );	
+	}
+}
+
+// -----------------------------------------------------------------------------
+// CPolicySet::AddElementL
+// -----------------------------------------------------------------------------
+//
+void CPolicySet::AddElementL( CPolicyParser *aParser, CElementBase * aElement)
+{
+	if ( aElement->ElementType() == ETarget ) 
+	{
+		aParser->HandleErrorL( iTarget, ParserErrors::UnexpectedElement, aParser->ActiveElementName());	
+		AddToElementListL( aElement, ETrue);
+		iTarget = aElement;
+	}
+	else if ( aElement->ElementType() == EPolicy ||  aElement->ElementType() == EPolicySet) 
+	{
+		AddToElementListL( aElement, ETrue);
+	}
+	else
+	if ( aElement->ElementType() == EDescription )
+	{
+		aParser->HandleErrorL( iDescription, ParserErrors::UnexpectedElement, aParser->ActiveElementName());	
+		AddToElementListL( aElement, ETrue);
+		iDescription = aElement;
+	}
+	else
+	{	
+		aParser->HandleErrorL( ParserErrors::UnexpectedElement, aParser->ActiveElementName());
+	}
+};
+
+// -----------------------------------------------------------------------------
+// CPolicySet::AddIdElementL
+// -----------------------------------------------------------------------------
+//
+
+void CPolicySet::AddIdElementL( CElementBase * aElement)
+{
+	__ASSERT_ALWAYS ( aElement, User::Panic(PolicyParserPanic, KErrCorrupt));
+	
+	if ( aElement->ElementType() == ETarget )
+	{
+		iTarget = aElement;
+	}
+	else
+	if ( aElement->ElementType() == EDescription )
+	{
+		iDescription = aElement;
+	}
+	
+	AddToElementListL( aElement, EFalse);
+}
+
+// -----------------------------------------------------------------------------
+// CPolicySet::DecodeElementL
+// -----------------------------------------------------------------------------
+//
+
+HBufC8 * CPolicySet::DecodeElementL( const  TLanguageSelector &aLanguage, const TDecodeMode &aMode)
+{
+	RDEBUG("PolicyEngineServer: Decode PolicySet element");
+
+	__ASSERT_ALWAYS ( iPolicySetId, User::Panic(PolicyParserPanic, KErrCorrupt));
+	__ASSERT_ALWAYS ( iPolicyCompiningAlg, User::Panic(PolicyParserPanic, KErrCorrupt));
+	
+	CheckAllElementsL();
+	TElementReserver reserver( Container());
+	
+	TInt size = 16;
+
+	size += 2 * PolicyLanguage::PolicySet::PolicySet[ aLanguage].Length();
+
+	size += PolicyLanguage::PolicySet::PolicySetId[ aLanguage].Length();
+	size += iPolicySetId->Length();
+
+	size += PolicyLanguage::PolicySet::PolicyCombiningAlgId[ aLanguage].Length();
+	
+	
+	const TDesC8& policyCompiningAlg = SelectCorrectValue( aLanguage, *iPolicyCompiningAlg);
+	size += policyCompiningAlg.Length();
+	
+	RContentBuilder builder;
+	CleanupClosePushL( builder);
+	
+	for ( TInt i(0); i < ElementCount(); i++)
+	{
+		CElementBase * element = Element(i);
+		builder.AddContentL( DecodeElementOrIdL( aLanguage, element, aMode));
+	}	
+
+	HBufC8* rules = builder.ContentL();
+	CleanupStack::PopAndDestroy( &builder);
+	CleanupStack::PushL(rules);
+	
+	if (rules) size += rules->Length();
+	
+	HBufC8 * hbuf = HBufC8::NewLC( size);
+	TPtr8 ptr = hbuf->Des();
+	
+	ptr.Append( '<');
+	ptr.Append( PolicyLanguage::PolicySet::PolicySet[ aLanguage]);
+	ptr.Append( ' ');
+	ptr.Append( PolicyLanguage::PolicySet::PolicySetId[ aLanguage]);
+	ptr.Append( _L8("=\""));
+	ptr.Append( *iPolicySetId);
+	ptr.Append( _L8("\" "));
+	ptr.Append( PolicyLanguage::PolicySet::PolicyCombiningAlgId[ aLanguage]);
+	ptr.Append( _L8("=\""));
+	ptr.Append( policyCompiningAlg);
+	ptr.Append( _L8("\">"));
+	
+	if (rules) 
+	{
+		ptr.Append(*rules);			
+	}
+	
+	ptr.Append( _L8("</"));
+	ptr.Append( PolicyLanguage::PolicySet::PolicySet[ aLanguage]);
+	ptr.Append( '>');											   
+
+	CleanupStack::Pop( hbuf);
+	CleanupStack::PopAndDestroy( rules);
+	
+	reserver.Release();
+
+	return hbuf;	
+}
+
+// -----------------------------------------------------------------------------
+// CPolicySet::ValidElement
+// -----------------------------------------------------------------------------
+//
+
+TBool CPolicySet::ValidElement()
+{
+	return iPolicySetId && iPolicyCompiningAlg;
+}
+
+// -----------------------------------------------------------------------------
+// CPolicySet::MatchL
+// -----------------------------------------------------------------------------
+//
+
+
+TMatchResponse CPolicySet::MatchL( CPolicyProcessor* aPolicyProcessor)
+{
+#ifndef __POLICY_BASE_CREATOR_TOOL
+
+	CPolicyStorage::PolicyStorage()->CheckElementL( this);
+	RDEBUG8_2("PolicyEngineServer: %S match evaluation started", ExternalId());
+
+	//check policyset target
+	if ( iTarget)
+	{
+		//reserve eleemnt
+		TElementReserver targetReserver( iTarget);
+		CPolicyStorage::PolicyStorage()->CheckElementL( iTarget);
+		
+		//and check target match
+		TMatchResponse response = iTarget->MatchL( aPolicyProcessor);
+		targetReserver.Release();
+
+		if ( response == EUnMatch )
+		{
+			return ENotApplicable;
+		}
+	}
+
+	__ASSERT_ALWAYS ( iPolicyCompiningAlg, User::Panic(PolicyParserPanic, KErrCorrupt));
+
+	//set up combining algorithm
+	TCombiningAlgorith combiner( *iPolicyCompiningAlg);
+
+	//loop all policies and policysets and combine their results 
+	for ( TInt i(0); i < ElementCount(); i++)
+	{
+		CElementBase * element = Element(i);		
+		TElementReserver elementReserver( element);
+
+		//select only policies and sets
+		if ( element->ElementType() == EPolicy || element->ElementType() == EPolicySet)
+		{
+			CPolicyStorage::PolicyStorage()->CheckElementL( element );
+			combiner.AddInput( element->MatchL( aPolicyProcessor));
+		}
+		
+		elementReserver.Release();
+	}	
+
+	RDEBUG8_2("PolicyEngineServer: %S match evaluation finished", ExternalId());
+
+	return combiner.Result();
+
+#endif // __POLICY_BASE_CREATOR_TOOL
+}
+
+
+// -----------------------------------------------------------------------------
+// CPolicy::CPolicy
+// -----------------------------------------------------------------------------
+//
+
+CPolicy::CPolicy()
+{
+	iElementType = EPolicy;
+	iElementName.Set( PolicyLanguage::NativeLanguage::Policy::Policy);
+}
+
+// -----------------------------------------------------------------------------
+// CPolicy::~CPolicy
+// -----------------------------------------------------------------------------
+//
+
+CPolicy::~CPolicy()
+{
+	delete iPolicyId;
+	delete iRuleCompiningAlg;
+}
+
+// -----------------------------------------------------------------------------
+// CPolicy::NewL
+// -----------------------------------------------------------------------------
+//
+
+CPolicy * CPolicy::NewL()
+{
+	return new (ELeave) CPolicy();
+}
+
+// -----------------------------------------------------------------------------
+// CPolicy::IdentificateType
+// -----------------------------------------------------------------------------
+//
+
+TBool CPolicy::IdentificateType( const TDesC8& aElementName)
+{
+	return ( aElementName == PolicyLanguage::NativeLanguage::Policy::Policy);			
+}
+
+// -----------------------------------------------------------------------------
+// CPolicy::AddAttributeL
+// -----------------------------------------------------------------------------
+//
+
+void CPolicy::AddAttributeL( CPolicyParser *aParser, const TDesC8& aName, const TDesC8& aValue)
+{
+	if ( aName == PolicyLanguage::NativeLanguage::Policy::PolicyId)
+	{
+		aParser->HandleErrorL( iPolicyId , ParserErrors::UnexpectedAttribute, aName);	
+		iPolicyId = aValue.AllocL();
+		iExternalId = iPolicyId;
+		aParser->CheckExternalIdL( iExternalId);
+	}
+	else	
+	if ( aName == PolicyLanguage::NativeLanguage::Policy::RuleCombiningAlgId)
+	{
+		aParser->HandleErrorL( iRuleCompiningAlg, ParserErrors::UnexpectedAttribute, aName);	
+		aParser->CheckCompiningAlgorithmsL( EPolicy, aValue);
+		iRuleCompiningAlg = aValue.AllocL();
+	}
+	else
+	{
+		aParser->HandleErrorL( ParserErrors::UnexpectedAttribute, aName);	
+	}
+}
+
+// -----------------------------------------------------------------------------
+// CPolicy::AddElementL
+// -----------------------------------------------------------------------------
+//
+void CPolicy::AddElementL( CPolicyParser *aParser, CElementBase * aElement)
+{
+	if ( aElement->ElementType() == ETarget ) 
+	{
+		aParser->HandleErrorL( iTarget, ParserErrors::UnexpectedElement, aParser->ActiveElementName());	
+		AddToElementListL( aElement, ETrue);
+		iTarget = aElement;
+	}
+	else
+	if ( aElement->ElementType() == EDescription )
+	{
+		aParser->HandleErrorL( iDescription, ParserErrors::UnexpectedElement, aParser->ActiveElementName());	
+		AddToElementListL( aElement, ETrue);
+		iDescription = aElement;
+	}
+	else if ( aElement->ElementType() == ERule ) 
+	{
+		AddToElementListL( aElement, ETrue);
+	}
+	else
+	{	
+		aParser->HandleErrorL( ParserErrors::UnexpectedElement, aParser->ActiveElementName());
+	}
+};
+
+// -----------------------------------------------------------------------------
+// CPolicy::AddIdElementL
+// -----------------------------------------------------------------------------
+//
+
+void CPolicy::AddIdElementL( CElementBase * aElement)
+{
+	__ASSERT_ALWAYS ( aElement, User::Panic(PolicyParserPanic, KErrCorrupt));
+	
+	if ( aElement->ElementType() == ETarget )
+	{
+		iTarget = aElement;
+	}
+	else
+	if ( aElement->ElementType() == EDescription )
+	{
+		iDescription = aElement;
+	}
+	
+	AddToElementListL( aElement, EFalse);
+}
+
+// -----------------------------------------------------------------------------
+// CPolicy::ValidElement
+// -----------------------------------------------------------------------------
+//
+
+TBool CPolicy::ValidElement()
+{
+	return iPolicyId && iRuleCompiningAlg;
+}
+
+// -----------------------------------------------------------------------------
+// CPolicy::DecodeElementL
+// -----------------------------------------------------------------------------
+//
+
+HBufC8 * CPolicy::DecodeElementL( const  TLanguageSelector &aLanguage, const TDecodeMode &aMode)
+{
+	RDEBUG("PolicyEngineServer: Decode Policy element");
+
+
+	__ASSERT_ALWAYS ( iPolicyId, User::Panic(PolicyParserPanic, KErrCorrupt));
+	__ASSERT_ALWAYS ( iRuleCompiningAlg, User::Panic(PolicyParserPanic, KErrCorrupt));
+	
+	CheckAllElementsL();
+	TElementReserver reserver( Container());
+	
+	
+	TInt size = 16;
+
+	size += 2 * PolicyLanguage::Policy::Policy[ aLanguage].Length();
+
+	size += PolicyLanguage::Policy::PolicyId[ aLanguage].Length();
+	const TDesC8& policyId = SelectCorrectValue( aLanguage, *iPolicyId);
+	size += policyId.Length();
+
+	size += PolicyLanguage::Policy::RuleCombiningAlgId[ aLanguage].Length();
+	const TDesC8& ruleCompiningAlg = SelectCorrectValue( aLanguage, *iRuleCompiningAlg);
+	size += ruleCompiningAlg.Length();
+	
+		
+	HBufC8 * rules = NULL;
+	CleanupStack::PushL(rules);
+	
+	for ( TInt i(0); i < ElementCount(); i++)
+	{
+		CElementBase * element = Element(i);
+
+		HBufC8 * decode = DecodeElementOrIdL( aLanguage, element, aMode);
+		CleanupStack::PushL( decode);		
+	
+		if ( rules )
+		{
+			rules = rules->ReAllocL( rules->Length() + decode->Length() + 10);
+		}
+		else
+		{
+			rules = HBufC8::NewL( decode->Length() + 10);
+		}
+		
+		rules->Des().Append( *decode);
+		CleanupStack::PopAndDestroy();		//decode
+		CleanupStack::Pop();				//old rules or null...
+		CleanupStack::PushL(rules);			
+	}	
+						//rules or null
+		
+	if (rules) size += rules->Length();
+	
+	HBufC8 * hbuf = HBufC8::NewLC( size);
+	TPtr8 ptr = hbuf->Des();
+	
+	ptr.Append('<');
+	ptr.Append(PolicyLanguage::Policy::Policy[ aLanguage]);
+	ptr.Append(' ');
+	ptr.Append(PolicyLanguage::Policy::PolicyId[ aLanguage]);
+	ptr.Append( _L8("=\""));
+	ptr.Append( policyId);
+	ptr.Append( _L8("\" "));
+	ptr.Append(PolicyLanguage::Policy::RuleCombiningAlgId[ aLanguage]);
+	ptr.Append( _L8("=\""));
+	ptr.Append( ruleCompiningAlg);
+	ptr.Append( _L8("\">"));
+	if (rules) ptr.Append(*rules);	
+	ptr.Append(_L8("</"));
+	ptr.Append(PolicyLanguage::Policy::Policy[ aLanguage]);
+	ptr.Append('>');											   
+
+	CleanupStack::Pop();
+	CleanupStack::PopAndDestroy();
+
+	reserver.Release();
+
+	return hbuf;	
+}
+
+// -----------------------------------------------------------------------------
+// CPolicy::
+// -----------------------------------------------------------------------------
+//
+
+
+TMatchResponse CPolicy::MatchL( CPolicyProcessor* aPolicyProcessor)
+{
+#ifndef __POLICY_BASE_CREATOR_TOOL
+
+	CPolicyStorage::PolicyStorage()->CheckElementL( this);
+	RDEBUG8_2("PolicyEngineServer: %S match evaluation started", ExternalId());
+
+	if ( iTarget)
+	{
+		TElementReserver targetReserver( iTarget);
+		CPolicyStorage::PolicyStorage()->CheckElementL( iTarget);
+		TMatchResponse response = iTarget->MatchL( aPolicyProcessor);
+		targetReserver.Release();
+		
+		if ( response == EUnMatch )
+		{
+			return ENotApplicable;
+		}
+	}
+
+	__ASSERT_ALWAYS ( iRuleCompiningAlg, User::Panic(PolicyParserPanic, KErrCorrupt));
+
+	TCombiningAlgorith combiner( *iRuleCompiningAlg);
+
+	for ( TInt i(0); i < ElementCount(); i++)
+	{
+		CElementBase * element = Element(i);	
+		TElementReserver elementReserver( element);	
+
+		if ( element->ElementType() == ERule)
+		{
+			CPolicyStorage::PolicyStorage()->CheckElementL( element);
+			CRule * rule = (CRule*) element;
+			combiner.AddInput( rule->MatchL( aPolicyProcessor), rule->Effect());
+		}
+		
+		elementReserver.Release();
+	}	
+
+	RDEBUG8_2("PolicyEngineServer: %S match evaluation finished", ExternalId());
+	return combiner.Result();
+
+#endif// __POLICY_BASE_CREATOR_TOOL
+}
+
+
+// -----------------------------------------------------------------------------
+// CAttribute::
+// -----------------------------------------------------------------------------
+//
+
+CAttribute::CAttribute()
+{
+	iSaveType = ESubElement;
+}
+
+// -----------------------------------------------------------------------------
+// CAttribute::
+// -----------------------------------------------------------------------------
+//
+
+CAttribute * CAttribute::NewL( const TDesC8& aAttributeId, const TBool& aAttributeValue)
+{
+	CAttribute * self = new (ELeave) CAttribute();
+	CleanupStack::PushL( self);
+	
+	using namespace PolicyLanguage::AttributeValues;
+
+	//create attribute with true or false value	
+	if ( aAttributeValue  )
+	{
+		self->ConstructL( aAttributeId, BooleanTrue[ENative], BooleanDataType[ENative]);
+	}
+	else
+	{
+		self->ConstructL( aAttributeId, BooleanFalse[ENative], BooleanDataType[ENative]);
+	}
+	
+	CleanupStack::Pop( self);
+	
+	return self;
+}
+
+// -----------------------------------------------------------------------------
+// CAttribute::
+// -----------------------------------------------------------------------------
+//
+
+
+CAttribute * CAttribute::NewL( const TDesC8& aAttributeId, const TDesC8& aAttributeValue, const TDesC8& aDataType)
+{
+	CAttribute * self = new (ELeave) CAttribute();
+	
+	CleanupStack::PushL( self);
+	self->ConstructL( aAttributeId, aAttributeValue, aDataType );
+	CleanupStack::Pop( self);
+	
+	return self;
+}
+
+// -----------------------------------------------------------------------------
+// CAttribute::
+// -----------------------------------------------------------------------------
+//
+
+
+void CAttribute::ConstructL( const TDesC8& aAttributeId, const TDesC8& aAttributeValue, const TDesC8& aDataType)
+{
+	iAttributeValue = CAttributeValue::NewL( aAttributeValue, aDataType);
+	iElementType = EAttribute;
+	
+	AddToElementListL( iAttributeValue, ETrue);
+	
+	iAttributeId = aAttributeId.AllocL();
+	iDataType = aDataType.AllocL();
+}
+
+// -----------------------------------------------------------------------------
+// CAttribute::
+// -----------------------------------------------------------------------------
+//
+
+CAttribute::~CAttribute()
+{
+	delete iDataType;
+	delete iAttributeId;
+}
+
+// -----------------------------------------------------------------------------
+// CAttribute::
+// -----------------------------------------------------------------------------
+//
+	
+CAttributeValue * CAttribute::AttributeValue()
+{
+	return iAttributeValue;	
+}
+
+// -----------------------------------------------------------------------------
+// CAttribute::
+// -----------------------------------------------------------------------------
+//
+
+TDesC8& CAttribute::AttributeId()
+{
+	return *iAttributeId;	
+}
+
+// -----------------------------------------------------------------------------
+// CAttribute::
+// -----------------------------------------------------------------------------
+//
+
+TDesC8& CAttribute::AttributeType()
+{
+	return *iDataType;
+}
+
+// -----------------------------------------------------------------------------
+// CRule::
+// -----------------------------------------------------------------------------
+//
+
+CRule::CRule()
+{
+	iElementType = ERule;
+	iElementName.Set( PolicyLanguage::NativeLanguage::Rule::Rule);
+}
+
+// -----------------------------------------------------------------------------
+// CRule::
+// -----------------------------------------------------------------------------
+//
+
+
+CRule::~CRule()
+{
+	delete iEffect;
+	delete iRuleId;
+}
+
+// -----------------------------------------------------------------------------
+// CRule::
+// -----------------------------------------------------------------------------
+//
+
+		
+CRule * CRule::NewL()
+{
+	return new (ELeave) CRule();
+}
+
+// -----------------------------------------------------------------------------
+// CRule::
+// -----------------------------------------------------------------------------
+//
+
+
+TBool CRule::IdentificateType( const TDesC8& aElementName)
+{
+	return ( aElementName == PolicyLanguage::NativeLanguage::Rule::Rule);		
+}
+
+// -----------------------------------------------------------------------------
+// CRule::
+// -----------------------------------------------------------------------------
+//
+			
+
+HBufC8 * CRule::DecodeElementL( const  TLanguageSelector &aLanguage, const TDecodeMode &aMode)
+{
+	RDEBUG("PolicyEngineServer: Decode Rule element");
+
+	__ASSERT_ALWAYS ( iEffect, User::Panic(PolicyParserPanic, KErrCorrupt));
+	__ASSERT_ALWAYS ( iRuleId, User::Panic(PolicyParserPanic, KErrCorrupt));
+	__ASSERT_ALWAYS ( iTarget, User::Panic(PolicyParserPanic, KErrCorrupt));
+	
+	CheckAllElementsL();
+	TElementReserver reserver( Container());
+
+	TInt size = 16;
+
+	size += 2 * PolicyLanguage::Rule::Rule[ aLanguage].Length();
+
+	size += PolicyLanguage::Rule::RuleId[ aLanguage].Length();
+	const TDesC8& ruleId = SelectCorrectValue( aLanguage, *iRuleId);
+	size += ruleId.Length();
+
+	size += PolicyLanguage::Rule::Effect[ aLanguage].Length();
+	const TDesC8& effect = SelectCorrectValue( aLanguage, *iEffect);
+	size += effect.Length();
+	
+	HBufC8 * elements = NULL;
+	CleanupStack::PushL( elements);
+	
+	for ( TInt i(0); i < ElementCount(); i++)
+	{
+		CElementBase * element = Element(i);
+		
+		HBufC8 * decode = DecodeElementOrIdL( aLanguage, element, aMode);
+		
+		CleanupStack::PushL( decode);		
+		
+		if ( elements)
+		{
+			elements = elements->ReAlloc( elements->Length() + decode->Length());
+		}
+		else
+		{
+			elements = HBufC8::NewL( decode->Length() + 10);
+		}
+		
+		elements->Des().Append( *decode);
+		CleanupStack::PopAndDestroy();
+		CleanupStack::Pop();
+		CleanupStack::PushL( elements);
+	}	
+	
+	if ( elements) size += elements->Length();
+
+	HBufC8 * hbuf = HBufC8::NewLC( size);
+
+	TPtr8 ptr = hbuf->Des();
+	
+	ptr.Append('<');
+	ptr.Append(PolicyLanguage::Rule::Rule[ aLanguage]);
+	ptr.Append(' ');
+	ptr.Append(PolicyLanguage::Rule::RuleId[ aLanguage]);
+	ptr.Append(_L8("=\""));
+	ptr.Append( ruleId);
+	ptr.Append(_L8("\" "));
+	ptr.Append(PolicyLanguage::Rule::Effect[ aLanguage]);
+	ptr.Append(_L8("=\""));
+	ptr.Append( effect);
+	ptr.Append(_L8("\">"));
+	if ( elements) ptr.Append(*elements);	
+	ptr.Append(_L8("</"));
+	ptr.Append(PolicyLanguage::Rule::Rule[ aLanguage]);
+	ptr.Append('>');											   
+
+	CleanupStack::Pop();
+	CleanupStack::PopAndDestroy();
+	
+	reserver.Release();
+	
+	return hbuf;	
+}
+
+
+// -----------------------------------------------------------------------------
+// CRule::AddIdElementL
+// -----------------------------------------------------------------------------
+//
+const TDesC8& CRule::EffectValue()
+{
+	if ( iEffect)
+	{
+		return *iEffect;
+	}
+	
+	return KNullDesC8;
+}
+
+// -----------------------------------------------------------------------------
+// CRule::SetRuleIdL
+// -----------------------------------------------------------------------------
+//
+void CRule::SetRuleIdL( const TDesC8& aName)
+{
+	delete iExternalId;
+	iExternalId = NULL;
+	iRuleId = iExternalId = aName.AllocL();
+}
+
+
+// -----------------------------------------------------------------------------
+// CRule::SetEffectL
+// -----------------------------------------------------------------------------
+//
+void CRule::SetEffectL( const TDesC8& aEffect)
+{
+	delete iEffect;
+	iEffect = NULL;
+	iEffect = aEffect.AllocL();
+	
+}
+
+
+
+// -----------------------------------------------------------------------------
+// CRule::GetTarget
+// -----------------------------------------------------------------------------
+//
+
+CTarget* CRule::GetTarget()
+{
+	return (CTarget*) iTarget;
+}
+
+
+// -----------------------------------------------------------------------------
+// CRule::AddIdElementL
+// -----------------------------------------------------------------------------
+//
+
+
+void CRule::AddIdElementL( CElementBase * aElement)
+{
+	__ASSERT_ALWAYS ( aElement, User::Panic(PolicyParserPanic, KErrCorrupt));
+	
+	if ( aElement->ElementType() == ETarget )
+	{
+		iTarget = aElement;
+	}
+	else
+	if ( aElement->ElementType() == ECondition )
+	{
+		iCondition = aElement;
+	}
+	else
+	if ( aElement->ElementType() == EDescription )
+	{
+		iDescription = aElement;
+	}
+	
+	AddToElementListL( aElement, EFalse);
+}
+
+// -----------------------------------------------------------------------------
+// CRule::AddAttributeL
+// -----------------------------------------------------------------------------
+//
+
+
+void CRule::AddAttributeL( CPolicyParser *aParser, const TDesC8& aName, const TDesC8& aValue)
+{
+	if ( aName == PolicyLanguage::NativeLanguage::Rule::RuleId)
+	{
+		aParser->HandleErrorL( iRuleId , ParserErrors::UnexpectedAttribute, aName);	
+		iRuleId = aValue.AllocL();
+		iExternalId = iRuleId;
+		aParser->CheckExternalIdL( iExternalId);
+	}
+	else	
+	if ( aName == PolicyLanguage::NativeLanguage::Rule::Effect)
+	{
+		aParser->HandleErrorL( iEffect, ParserErrors::UnexpectedAttribute, aName);	
+		aParser->CheckEffectL( aValue);
+		iEffect = aValue.AllocL();
+	}
+	else
+	{
+		aParser->HandleErrorL( ParserErrors::UnexpectedAttribute, aName );	
+	}
+}
+
+// -----------------------------------------------------------------------------
+// CRule::AddElementL
+// -----------------------------------------------------------------------------
+//
+
+
+void CRule::AddElementL( CPolicyParser *aParser, CElementBase * aElement)
+{
+	if ( aElement->ElementType() == ETarget ) 
+	{
+		if ( aParser )
+		{
+			aParser->HandleErrorL( iTarget, ParserErrors::UnexpectedElement, aParser->ActiveElementName());	
+		}
+		
+		AddToElementListL( aElement, ETrue);
+		iTarget = aElement;
+	} else
+	if ( aElement->ElementType() == EDescription )
+	{
+		aParser->HandleErrorL( iDescription, ParserErrors::UnexpectedElement, aParser->ActiveElementName());	
+		AddToElementListL( aElement, ETrue);
+		iDescription = aElement;
+	} else
+	if ( aElement->ElementType() == ECondition )
+	{
+		aParser->HandleErrorL( iCondition, ParserErrors::UnexpectedElement, aParser->ActiveElementName());	
+		AddToElementListL( aElement, ETrue);
+		iCondition = aElement;
+	}	else
+	{	
+		aParser->HandleErrorL( ParserErrors::UnexpectedElement, aParser->ActiveElementName());
+	}
+};
+
+// -----------------------------------------------------------------------------
+// CRule::ValidElement
+// -----------------------------------------------------------------------------
+//
+
+
+TBool CRule::ValidElement()
+{
+	return iEffect && iRuleId && iTarget;
+}
+
+// -----------------------------------------------------------------------------
+// CRule::MatchL
+// -----------------------------------------------------------------------------
+//
+
+
+TMatchResponse CRule::MatchL( CPolicyProcessor* aPolicyProcessor)
+{
+#ifndef __POLICY_BASE_CREATOR_TOOL
+
+	__ASSERT_ALWAYS ( iTarget, User::Panic(PolicyParserPanic, KErrCorrupt));
+
+	//check rule target match
+	TElementReserver targetReserver( iTarget);
+	CPolicyStorage::PolicyStorage()->CheckElementL( iTarget);
+	RDEBUG8_2("PolicyEngineServer: %S match evaluation started", ExternalId());
+	TMatchResponse response = iTarget->MatchL( aPolicyProcessor);
+
+	//if match evaluated effect of rule is checked otherwise result is NOT APPLICABLE
+	if ( response == EMatch)
+	{
+		RDEBUG8_2("PolicyEngineServer: %S evaluated: MATCH", ExternalId());
+
+		//effect if deny or permit, in effect case also condition is evaluated 
+		if ( *iEffect == PolicyLanguage::Rule::Permit[ ENative])
+		{
+			RDEBUG8_2("PolicyEngineServer: %S, Effect == PERMIT", ExternalId());
+			response = EPermit;
+		
+			if ( iCondition)
+			{
+				//condition exists
+				RDEBUG8_2("PolicyEngineServer: %S contains condition", ExternalId());
+
+				//avaluated condition value (true or false)
+				TElementReserver targetReserver( iCondition);
+				CPolicyStorage::PolicyStorage()->CheckElementL( iCondition);
+				TMatchResponse condResp = ((CCondition*)iCondition)->ConditionValueL( aPolicyProcessor);
+				targetReserver.Release();
+
+				//condition == unmatch -> conditition is not valid -> result will be NOT APPLICABLE
+				if ( condResp == EUnMatch)
+				{
+					RDEBUG8_2("PolicyEngineServer: %S, condition evaluated -> NOT APPLICABLE", ExternalId());
+					response = ENotApplicable;
+				}
+				else if ( condResp == EIndeterminate)
+				{
+					//error in condition evaluation -> result will be INDETERMINATE
+					RDEBUG8_2("PolicyEngineServer: %S, condition evaluated -> INDETERMINATE", ExternalId());
+					response = EIndeterminate;
+				}
+				else
+				{
+					//other result is permit....
+					response = EPermit;
+					RDEBUG8_2("PolicyEngineServer: %S, condition evaluated -> PERMIT", ExternalId());
+				}
+			}
+		}
+		else
+		{
+			//in DENY is clear -> result will be DENY
+			RDEBUG8_2("PolicyEngineServer: %S, Effect == DENY", ExternalId());
+			response = EDeny;
+		}
+	}
+	else
+	{
+		RDEBUG8_2("PolicyEngineServer: %S -> NOT APPLICABLE", ExternalId());
+		response = ENotApplicable;
+	}
+	
+	RDEBUG8_2("PolicyEngineServer: %S match evaluation finished", ExternalId());
+	targetReserver.Release();
+	return response;
+
+#endif// __POLICY_BASE_CREATOR_TOOL
+}
+
+
+// -----------------------------------------------------------------------------
+// CRule::Effect
+// -----------------------------------------------------------------------------
+//
+
+
+TMatchResponse CRule::Effect()
+{
+	TMatchResponse response;
+	if ( *iEffect == PolicyLanguage::Rule::Permit[ ENative])
+	{
+		response = EPermit;
+	}
+	else
+	{
+		response = EDeny;
+	}
+	
+	return response;
+}
+
+// -----------------------------------------------------------------------------
+// CTarget::CTarget
+// -----------------------------------------------------------------------------
+//
+
+
+CTarget::CTarget()
+{
+	iElementType = ETarget;		
+	iElementName.Set( PolicyLanguage::NativeLanguage::Rule::Target);
+	
+	iSaveType = ESubElement;
+}
+
+// -----------------------------------------------------------------------------
+// CTarget::~CTarget
+// -----------------------------------------------------------------------------
+//
+
+CTarget::~CTarget()
+{
+}
+
+// -----------------------------------------------------------------------------
+// CTarget::NewL
+// -----------------------------------------------------------------------------
+//
+
+CTarget * CTarget::NewL()
+{
+	return new (ELeave) CTarget();
+}
+
+
+// -----------------------------------------------------------------------------
+// CTarget::GetMatchContainers
+// -----------------------------------------------------------------------------
+//
+
+void CTarget::GetMatchContainersL( RMatchObjectArray& aMatchContainer )
+{
+	if ( iSubjects)
+	{
+		((CItemContainer*)iSubjects)->GetMatchContainersL( aMatchContainer);
+	}
+	if ( iResources)
+	{
+		((CItemContainer*)iResources)->GetMatchContainersL( aMatchContainer);
+	}
+	if ( iActions)
+	{
+		((CItemContainer*)iActions)->GetMatchContainersL( aMatchContainer);
+	}
+	if ( iEnvironments)
+	{
+		((CItemContainer*)iEnvironments)->GetMatchContainersL( aMatchContainer);
+	}
+}
+
+
+
+// -----------------------------------------------------------------------------
+// CTarget::IdentificateType
+// -----------------------------------------------------------------------------
+//
+
+TBool CTarget::IdentificateType( const TDesC8& aElementName)
+{
+	return ( aElementName == PolicyLanguage::NativeLanguage::Rule::Target);	
+}
+
+// -----------------------------------------------------------------------------
+// CTarget::DecodeElementL
+// -----------------------------------------------------------------------------
+//
+			
+HBufC8 * CTarget::DecodeElementL( const  TLanguageSelector &aLanguage, const TDecodeMode &aMode)
+{
+	RDEBUG("PolicyEngineServer: Decode Target element");
+
+	TPtrC8 ptr;
+	ptr.Set( PolicyLanguage::Rule::Target[ aLanguage]);	
+
+	if ( !ElementCount()) 
+	{
+		return ElementHelper::DecodeEmptyElement( ptr);
+	}
+
+	CheckAllElementsL();
+	TElementReserver reserver( Container());
+
+	_LIT8( DecodeFormat, "<%S>%S</%S>");	
+	
+	TInt size(15);
+	size += 2 * ptr.Length();
+	
+	HBufC8 * elements = NULL;
+	CleanupStack::PushL( elements);
+	
+	for ( TInt i(0); i < ElementCount(); i++)
+	{
+		CElementBase * element = Element(i);
+		
+		HBufC8 * decode = DecodeElementOrIdL( aLanguage, element, aMode);
+		
+		CleanupStack::PushL( decode);		
+		
+		if ( elements)
+		{
+			elements = elements->ReAlloc( elements->Length() + decode->Length() + 10);;
+		}
+		else
+		{
+			elements = HBufC8::NewL( decode->Length() + 10);
+		}
+		
+		elements->Des().Append( *decode);
+		CleanupStack::PopAndDestroy();
+		CleanupStack::Pop();
+		CleanupStack::PushL( elements);
+	}	
+	
+	if (elements)
+	{
+	size += elements->Length();
+	}
+	
+	HBufC8 * hbuf = HBufC8::NewLC( size);
+	
+	hbuf->Des().Format( DecodeFormat, &ptr, elements, &ptr);
+
+	CleanupStack::Pop();
+	CleanupStack::PopAndDestroy();
+	
+	reserver.Release();
+	
+	return hbuf;	
+}
+
+// -----------------------------------------------------------------------------
+// CTarget::AddIdElementL
+// -----------------------------------------------------------------------------
+//
+
+void CTarget::AddIdElementL( CElementBase * aElement)
+{
+	if ( aElement->ElementType() == ESubjects )
+	{
+		iSubjects = aElement;	
+	}
+	else
+	if ( aElement->ElementType() == EActions )
+	{
+		iActions = aElement;
+	}
+	else
+	if ( aElement->ElementType() == EResources )
+	{
+		iResources = aElement; 	
+	}
+	else
+	if ( aElement->ElementType() == EEnvironments )
+	{
+		iEnvironments = aElement;	
+	}
+	
+	AddToElementListL( aElement, EFalse);
+}
+
+// -----------------------------------------------------------------------------
+// CTarget::ValidElement()
+// -----------------------------------------------------------------------------
+//
+
+TBool CTarget::ValidElement()
+{
+	//Target is allways valid
+	return ETrue;//(iSubjects || iActions || iResources || iEnvironments);
+}
+
+
+// -----------------------------------------------------------------------------
+// CTarget::MatchL()
+// -----------------------------------------------------------------------------
+//
+
+
+TMatchResponse CTarget::MatchL( CPolicyProcessor* aPolicyProcessor)
+{
+#ifndef __POLICY_BASE_CREATOR_TOOL
+
+	TMatchResponse response( ENotApplicable);
+	TBool atLeastOneMatchExecuted = EFalse;
+	CPolicyStorage * storage = CPolicyStorage::PolicyStorage();
+
+	//check all matches...
+	//if any subject exist, check match
+	if ( iSubjects )
+	{
+		TElementReserver element( iSubjects);
+		storage->CheckElementL( iSubjects);
+		response = iSubjects->MatchL( aPolicyProcessor);
+		atLeastOneMatchExecuted = ETrue;
+		element.Release();
+	} 
+	
+	//if not unmatch from previous elements, and any actions exist, check match
+	if ( response != EUnMatch && iActions)
+	{
+		TElementReserver element( iActions);
+		storage->CheckElementL( iActions);
+		response = iActions->MatchL( aPolicyProcessor);
+		atLeastOneMatchExecuted = ETrue;
+		element.Release();
+	}
+
+	//if not unmatch from previous elements, and any resources exist, check match
+	if ( response != EUnMatch  && iResources)
+	{
+		TElementReserver element( iResources);
+		storage->CheckElementL( iResources);
+		response = iResources->MatchL( aPolicyProcessor);
+		atLeastOneMatchExecuted = ETrue;
+		element.Release();
+	}
+
+	//if not unmatch from previous elements, and any environments exist, check match
+	if ( response != EUnMatch && iEnvironments)
+	{
+		TElementReserver element( iEnvironments);
+		storage->CheckElementL( iEnvironments);
+		response = iEnvironments->MatchL( aPolicyProcessor);
+		atLeastOneMatchExecuted = ETrue;
+		element.Release();
+	}
+	
+	//if target doesn't have any objects, it is applicable to any object...
+	if ( !atLeastOneMatchExecuted )
+	{
+		response = EMatch;
+	}
+	
+	if ( response == ENotApplicable)
+	{
+		response = EUnMatch;
+	}
+
+	return response;
+
+#endif //__POLICY_BASE_CREATOR_TOOL
+}
+
+
+// -----------------------------------------------------------------------------
+// CTarget::AddElementL()
+// -----------------------------------------------------------------------------
+//
+
+void CTarget::AddElementL( CPolicyParser *aParser, CElementBase * aElement)
+{
+	//check is element already exist and add it correct place
+	
+	if ( aElement->ElementType() == ESubjects )
+	{
+		if ( aParser )
+		{
+			aParser->HandleErrorL( iSubjects, ParserErrors::UnexpectedElement, aParser->ActiveElementName());
+		}
+		iSubjects = aElement;	
+	}
+	else
+	if ( aElement->ElementType() == EActions )
+	{
+		if ( aParser )
+		{
+			aParser->HandleErrorL( iActions, ParserErrors::UnexpectedElement, aParser->ActiveElementName());
+		}
+		iActions = aElement;
+	}
+	else
+	if ( aElement->ElementType() == EResources )
+	{
+		if ( aParser )
+		{
+			aParser->HandleErrorL( iResources, ParserErrors::UnexpectedElement, aParser->ActiveElementName());
+		}
+		iResources = aElement; 	
+	}
+	else
+	if ( aElement->ElementType() == EEnvironments )
+	{
+		if ( aParser )
+		{
+			aParser->HandleErrorL( iEnvironments, ParserErrors::UnexpectedElement, aParser->ActiveElementName());
+		}
+		iEnvironments = aElement;	
+	}
+	else
+		aParser->HandleErrorL( ParserErrors::UnexpectedElement, aParser->ActiveElementName());
+	
+	//add element also to element list
+	AddToElementListL( aElement, ETrue);
+}
+
+// -----------------------------------------------------------------------------
+// CItemContainer::CItemContainer()
+// -----------------------------------------------------------------------------
+//
+
+CItemContainer::CItemContainer()
+{
+	
+}
+
+// -----------------------------------------------------------------------------
+// CItemContainer::~CItemContainer()
+// -----------------------------------------------------------------------------
+//
+
+
+CItemContainer::~CItemContainer()
+{
+	
+}
+
+// -----------------------------------------------------------------------------
+// CItemContainer::DecodeElementL
+// -----------------------------------------------------------------------------
+//
+
+HBufC8 * CItemContainer::DecodeElementL( const  TLanguageSelector &aLanguage, const TDecodeMode &aMode  )
+{	
+	RDEBUG("PolicyEngineServer: Decode ItemContainer element");
+
+
+	_LIT8( DecodeFormat, "<%S>%S</%S>");	
+	
+	TInt size(15);
+	
+	TPtrC8 ptr;
+	if ( iElementType == ESubject )
+		ptr.Set( PolicyLanguage::MatchContainers::Subject[ aLanguage]);
+	else if ( iElementType == EAction )
+		ptr.Set( PolicyLanguage::MatchContainers::Action[ aLanguage]);
+	else if ( iElementType == EResource )
+		ptr.Set( PolicyLanguage::MatchContainers::Resource[ aLanguage]);
+	else if ( iElementType == EEnvironment )
+		ptr.Set( PolicyLanguage::MatchContainers::Environment[ aLanguage]);
+	else if ( iElementType == ESubjects )
+		ptr.Set( PolicyLanguage::MatchContainers::Subjects[ aLanguage]);
+	else if ( iElementType == EActions )
+		ptr.Set( PolicyLanguage::MatchContainers::Actions[ aLanguage]);
+	else if ( iElementType == EResources )
+		ptr.Set( PolicyLanguage::MatchContainers::Resources[ aLanguage]);
+	else 
+		ptr.Set( PolicyLanguage::MatchContainers::Environments[ aLanguage]);
+	
+	if ( !ElementCount()) 
+	{
+		return ElementHelper::DecodeEmptyElement( ptr);
+	}
+	
+	CheckAllElementsL();
+	TElementReserver reserver( Container());
+	
+	size += 2 * ptr.Length();
+	
+	HBufC8 * elements = NULL;
+	CleanupStack::PushL( elements);
+	
+	for ( TInt i(0); i < ElementCount(); i++)
+	{
+		CElementBase * element = Element(i);
+		
+		HBufC8 * decode = DecodeElementOrIdL( aLanguage, element, aMode);
+		
+		CleanupStack::PushL( decode);		
+		
+		if ( elements)
+		{
+			elements = elements->ReAlloc( elements->Length() + decode->Length() + 10);;
+		}
+		else
+		{
+			elements = HBufC8::NewL( decode->Length() + 10);
+		}
+		
+		elements->Des().Append( *decode);
+		
+		CleanupStack::PopAndDestroy();
+		CleanupStack::Pop();
+		CleanupStack::PushL( elements);		
+	}	
+	
+	if (elements)
+	{
+	size += elements->Length();
+	}
+	
+	HBufC8 * hbuf = HBufC8::NewLC( size);
+	
+	hbuf->Des().Format( DecodeFormat, &ptr, elements, &ptr);
+
+	CleanupStack::Pop( hbuf);
+	CleanupStack::PopAndDestroy();
+	
+	reserver.Release();	
+	
+	return hbuf;
+}
+
+// -----------------------------------------------------------------------------
+// CItemContainer::GetMatchContainersL
+// -----------------------------------------------------------------------------
+//
+
+void CItemContainer::GetMatchContainersL( RMatchObjectArray& aMatchContainer )
+{
+	for ( TInt i(0); i < ElementCount(); i++)
+	{
+		CElementBase * element = Element(i);
+		
+		__ASSERT_ALWAYS ( element, User::Panic( Panics::PolicyExecutionPanic, KErrCorrupt));
+		 
+		 TNativeElementTypes elementType = element->ElementType();
+
+		if ( elementType == ESubjectMatch ||
+			 elementType == EResourceMatch ||
+			 elementType == EActionMatch ||
+			 elementType == EEnvironmentMatch )
+		{
+			aMatchContainer.AppendL((CMatchObject*)element);
+		}
+		else if ( elementType == ESubject ||
+			 	  elementType == EResource ||
+			      elementType == EAction ||
+			 	  elementType == EEnvironment )
+		{
+			((CItemContainer*)element)->GetMatchContainersL(aMatchContainer);
+		}
+	}
+}
+
+
+// -----------------------------------------------------------------------------
+// CItemContainer::ValidElement
+// -----------------------------------------------------------------------------
+//
+
+TBool CItemContainer::ValidElement()
+{
+	//empty elements are possible
+	return ETrue; //( ElementCount() > 0); 
+}
+
+// -----------------------------------------------------------------------------
+// CItemContainer::MatchL
+// -----------------------------------------------------------------------------
+//
+
+
+TMatchResponse CItemContainer::MatchL( CPolicyProcessor* aPolicyProcessor)
+{
+#ifndef __POLICY_BASE_CREATOR_TOOL
+
+	//evaluate subject (or resouce...) components or subjectmatch (or resourcematch) components
+	for ( TInt i(0); i < ElementCount(); i++)
+	{
+		//reserve and check element
+		CElementBase * element = Element(i);
+		TElementReserver elementReserver( element); 
+		CPolicyStorage::PolicyStorage()->CheckElementL( element);
+
+		//avaluate match
+		TMatchResponse response = element->MatchL( aPolicyProcessor);
+		
+		elementReserver.Release();
+		
+		//if indeterminate -> result will be indeterminate
+		if ( response == EIndeterminate ) return EIndeterminate;
+		
+		
+		if ( response == EMatch )
+		{
+			//In OR-(subject) case one match is enough to evaluate result -> EMatch		
+			if ( iBooleanType == EOrBoolean ) 
+			{
+				return EMatch;					
+			}
+		}
+		else
+		{
+			//In AND-(subjectmatch) case one unmatch is enough to evaluate result -> EUnMatch		
+			if ( iBooleanType == EAndBoolean ) 
+			{
+				return EUnMatch;	
+			}
+		}
+	}
+	
+	//if this point is reached, match evaluation bases on component type (OR or AND)
+	//in OR cases it means that none of matched found
+	//in AND cases it means that none of unmatches founb
+	TMatchResponse response( EMatch);
+	if ( iBooleanType == EOrBoolean) 
+	{
+		response = EUnMatch;	
+	}
+	
+	return response;
+
+#endif // __POLICY_BASE_CREATOR_TOOL
+}	
+
+
+// -----------------------------------------------------------------------------
+// CItemContainer::
+// -----------------------------------------------------------------------------
+//	
+
+void CItemContainer::AddIdElementL( CElementBase * aElement)
+{
+	AddToElementListL( aElement, EFalse);
+}
+
+// -----------------------------------------------------------------------------
+// CItemContainer::
+// -----------------------------------------------------------------------------
+//
+
+void CItemContainer::AddElementL( CPolicyParser *aParser, CElementBase * aElement)
+{
+	if ( aElement->ElementType() == iAllowedType)
+		AddToElementListL( aElement, ETrue);
+	else
+		aParser->HandleErrorL( ParserErrors::UnexpectedElement, aParser->ActiveElementName());
+}
+
+// -----------------------------------------------------------------------------
+// CSubjects::
+// -----------------------------------------------------------------------------
+//
+
+CSubjects::CSubjects()
+{
+	iElementType = ESubjects;	
+	iAllowedType = ESubject;
+	iBooleanType = EOrBoolean;
+	iElementName.Set( PolicyLanguage::NativeLanguage::MatchContainers::Subjects);
+
+	iSaveType = ESubElement;
+}
+
+// -----------------------------------------------------------------------------
+// CSubjects::
+// -----------------------------------------------------------------------------
+//
+
+CSubjects::~CSubjects()
+{
+}
+
+// -----------------------------------------------------------------------------
+// CSubjects::
+// -----------------------------------------------------------------------------
+//
+		
+CSubjects * CSubjects::NewL()
+{
+	return new (ELeave) CSubjects();
+}
+
+// -----------------------------------------------------------------------------
+// CSubjects::
+// -----------------------------------------------------------------------------
+//
+
+TBool CSubjects::IdentificateType( const TDesC8& aElementName)
+{
+	return ( aElementName == PolicyLanguage::NativeLanguage::MatchContainers::Subjects);	
+}
+
+// -----------------------------------------------------------------------------
+// CSubject::
+// -----------------------------------------------------------------------------
+//
+
+CSubject::CSubject() 
+{
+	iElementType = ESubject;	
+	iAllowedType = ESubjectMatch;
+	iBooleanType = EAndBoolean;
+	iElementName.Set( PolicyLanguage::NativeLanguage::MatchContainers::Subject);
+
+	iSaveType = ESubElement;
+}
+
+// -----------------------------------------------------------------------------
+// CSubject::
+// -----------------------------------------------------------------------------
+//
+
+
+CSubject::~CSubject()
+{
+}
+	
+// -----------------------------------------------------------------------------
+// CSubject::
+// -----------------------------------------------------------------------------
+//
+	
+		
+CSubject * CSubject::NewL()
+{
+	return new (ELeave) CSubject();
+}
+
+// -----------------------------------------------------------------------------
+// CSubject::
+// -----------------------------------------------------------------------------
+//
+
+
+TBool CSubject::IdentificateType( const TDesC8& aElementName)
+{
+	return ( aElementName == PolicyLanguage::NativeLanguage::MatchContainers::Subject);	
+}
+
+// -----------------------------------------------------------------------------
+// CAction::
+// -----------------------------------------------------------------------------
+//
+
+
+CAction::CAction() 
+{
+	iElementType = EAction;	
+	iAllowedType = EActionMatch;
+	iBooleanType = EAndBoolean;
+	iElementName.Set( PolicyLanguage::NativeLanguage::MatchContainers::Action);
+
+	iSaveType = ESubElement;
+}
+
+// -----------------------------------------------------------------------------
+// CAction::
+// -----------------------------------------------------------------------------
+//
+
+
+CAction::~CAction()
+{
+}
+
+// -----------------------------------------------------------------------------
+// CAction::
+// -----------------------------------------------------------------------------
+//
+		
+CElementBase * CAction::NewL()
+{
+	return new (ELeave) CAction();
+}
+
+// -----------------------------------------------------------------------------
+// CAction::
+// -----------------------------------------------------------------------------
+//
+
+TBool CAction::IdentificateType( const TDesC8& aElementName)
+{
+	return ( aElementName == PolicyLanguage::NativeLanguage::MatchContainers::Action);	
+}
+
+// -----------------------------------------------------------------------------
+// CActions::
+// -----------------------------------------------------------------------------
+//
+
+
+CActions::CActions()
+{
+	iElementType = EActions;	
+	iAllowedType = EAction;
+	iBooleanType = EOrBoolean;
+	iElementName.Set( PolicyLanguage::NativeLanguage::MatchContainers::Actions);
+
+	iSaveType = ESubElement;
+}
+
+// -----------------------------------------------------------------------------
+// CActions::
+// -----------------------------------------------------------------------------
+//
+
+
+CActions::~CActions()
+{
+}
+	
+// -----------------------------------------------------------------------------
+// CActions::
+// -----------------------------------------------------------------------------
+//
+	
+		
+CElementBase * CActions::NewL()
+{
+	return new (ELeave) CActions();
+}
+
+// -----------------------------------------------------------------------------
+// CActions::
+// -----------------------------------------------------------------------------
+//
+
+
+TBool CActions::IdentificateType( const TDesC8& aElementName)
+{
+	return ( aElementName == PolicyLanguage::NativeLanguage::MatchContainers::Actions);	
+}
+
+// -----------------------------------------------------------------------------
+// CResource::
+// -----------------------------------------------------------------------------
+//
+
+
+
+CResource::CResource() 
+{
+	iElementType = EResource;	
+	iAllowedType = EResourceMatch;
+	iBooleanType = EAndBoolean;
+	iElementName.Set( PolicyLanguage::NativeLanguage::MatchContainers::Resource);
+
+	iSaveType = ESubElement;
+}
+
+// -----------------------------------------------------------------------------
+// CResource::
+// -----------------------------------------------------------------------------
+//
+
+
+CResource::~CResource()
+{
+}
+
+// -----------------------------------------------------------------------------
+// CResource::
+// -----------------------------------------------------------------------------
+//
+
+		
+CElementBase * CResource::NewL()
+{
+	return new (ELeave) CResource();
+}
+
+// -----------------------------------------------------------------------------
+// CResource::IdentificateType
+// -----------------------------------------------------------------------------
+//
+
+
+TBool CResource::IdentificateType( const TDesC8& aElementName)
+{
+	return ( aElementName == PolicyLanguage::NativeLanguage::MatchContainers::Resource);	
+}
+
+// -----------------------------------------------------------------------------
+// CResources::CResources
+// -----------------------------------------------------------------------------
+//
+
+
+CResources::CResources()
+{
+	iElementType = EResources;	
+	iAllowedType = EResource;
+	iBooleanType = EOrBoolean;
+	iElementName.Set( PolicyLanguage::NativeLanguage::MatchContainers::Resources);
+	
+	iSaveType = ESubElement;
+}
+
+
+// -----------------------------------------------------------------------------
+// CResources::
+// -----------------------------------------------------------------------------
+//
+
+
+CResources::~CResources()
+{
+}
+// -----------------------------------------------------------------------------
+// CResources::
+// -----------------------------------------------------------------------------
+//
+
+		
+CElementBase * CResources::NewL()
+{
+	return new (ELeave) CResources();
+}
+
+// -----------------------------------------------------------------------------
+// CResources::
+// -----------------------------------------------------------------------------
+//
+
+
+TBool CResources::IdentificateType( const TDesC8& aElementName)
+{
+	return ( aElementName == PolicyLanguage::NativeLanguage::MatchContainers::Resources);	
+}
+
+// -----------------------------------------------------------------------------
+// CEnviroment::
+// -----------------------------------------------------------------------------
+//
+
+
+CEnvironment::CEnvironment() 
+{
+	iElementType = EEnvironment;	
+	iAllowedType = EEnvironmentMatch;
+	iBooleanType = EAndBoolean;
+	iElementName.Set( PolicyLanguage::NativeLanguage::MatchContainers::Environment);
+
+	iSaveType = ESubElement;
+}
+
+// -----------------------------------------------------------------------------
+// CEnviroment::
+// -----------------------------------------------------------------------------
+//
+
+
+CEnvironment::~CEnvironment()
+{
+}
+
+// -----------------------------------------------------------------------------
+// CEnviroment::
+// -----------------------------------------------------------------------------
+//
+
+		
+CElementBase * CEnvironment::NewL()
+{
+	return new (ELeave) CEnvironment();
+}
+
+// -----------------------------------------------------------------------------
+// CEnviroment::
+// -----------------------------------------------------------------------------
+//
+
+TBool CEnvironment::IdentificateType( const TDesC8& aElementName)
+{
+	return ( aElementName == PolicyLanguage::NativeLanguage::MatchContainers::Environment);	
+}
+
+// -----------------------------------------------------------------------------
+// CEnviroments::
+// -----------------------------------------------------------------------------
+//
+
+
+CEnvironments::CEnvironments()
+{
+	iElementType = EEnvironments;	
+	iAllowedType = EEnvironment;
+	iBooleanType = EOrBoolean;
+	iElementName.Set( PolicyLanguage::NativeLanguage::MatchContainers::Environments);
+
+}
+
+// -----------------------------------------------------------------------------
+// CEnviroments::
+// -----------------------------------------------------------------------------
+//
+
+
+CEnvironments::~CEnvironments()
+{
+}
+
+// -----------------------------------------------------------------------------
+// CEnviroments::
+// -----------------------------------------------------------------------------
+//
+
+		
+CElementBase * CEnvironments::NewL()
+{
+	return new (ELeave) CEnvironments();
+}
+
+// -----------------------------------------------------------------------------
+// CEnviroments::
+// -----------------------------------------------------------------------------
+//
+
+
+TBool CEnvironments::IdentificateType( const TDesC8& aElementName)
+{
+	return ( aElementName == PolicyLanguage::NativeLanguage::MatchContainers::Environments);	
+}
+
+// -----------------------------------------------------------------------------
+// CAttributeDesignator::
+// -----------------------------------------------------------------------------
+//
+
+
+CAttributeDesignator::CAttributeDesignator()
+	: CElementBase() 
+{
+	iSaveType = ESubElement;
+}
+
+// -----------------------------------------------------------------------------
+// CAttributeDesignator::
+// -----------------------------------------------------------------------------
+//
+
+
+CAttributeDesignator::~CAttributeDesignator()
+{
+	delete iAttributeId;
+	delete iDataType;
+}
+
+// -----------------------------------------------------------------------------
+// CAttributeDesignator::
+// -----------------------------------------------------------------------------
+//
+
+	
+CElementBase * CAttributeDesignator::NewL( TNativeElementTypes aType)
+{
+	CElementBase * designator = NULL; 
+
+	if ( aType == ESubjectAttributeDesignator) designator = CSubjectAttributeDesignator::NewL();
+	else 
+	if ( aType == EActionAttributeDesignator) designator = CActionAttributeDesignator::NewL();
+	else 
+	if ( aType == EResourceAttributeDesignator) designator = CResourceAttributeDesignator::NewL();
+	else 
+	if ( aType == EEnvironmentAttributeDesignator) designator = CEnvironmentAttributeDesignator::NewL();
+	
+	return designator;
+}
+
+// -----------------------------------------------------------------------------
+// CAttributeDesignator::
+// -----------------------------------------------------------------------------
+//
+
+
+TDesC8& CAttributeDesignator::GetAttributeid()
+{
+	return *iAttributeId;	
+}
+
+// -----------------------------------------------------------------------------
+// CAttributeDesignator::
+// -----------------------------------------------------------------------------
+//
+
+
+TDesC8& CAttributeDesignator::GetDataType()
+{
+	return *iDataType;
+}
+
+// -----------------------------------------------------------------------------
+// CAttributeDesignator::
+// -----------------------------------------------------------------------------
+//
+
+
+TBool CAttributeDesignator::ValidElement()
+{
+	return iAttributeId && iDataType;
+}
+
+// -----------------------------------------------------------------------------
+// CAttributeDesignator::
+// -----------------------------------------------------------------------------
+//
+
+
+
+void CAttributeDesignator::AddAttributeL( CPolicyParser *aParser, const TDesC8& aName, const TDesC8& aValue)
+{	
+	if ( aName == PolicyLanguage::NativeLanguage::AttributeDesignators::AttributeId )
+	{
+		iAttributeId = aValue.AllocL();
+	}
+	else
+	if ( aName == PolicyLanguage::NativeLanguage::AttributeDesignators::DataType)
+	{
+		if ( aParser)
+		{
+			aParser->CheckDataTypeL( aValue);
+		}
+		iDataType = aValue.AllocL();
+	}
+	else
+	{
+		if ( aParser)
+		{
+			aParser->HandleErrorL( ParserErrors::UnexpectedAttribute, aName);
+		}
+	}
+}
+
+// -----------------------------------------------------------------------------
+// CAttributeDesignator::
+// -----------------------------------------------------------------------------
+//
+
+
+HBufC8 * CAttributeDesignator::DecodeElementL( const  TLanguageSelector &aLanguage, const TDecodeMode &/*aMode*/  )
+{
+	RDEBUG("PolicyEngineServer: Decode Attribute Designator element");
+
+
+	__ASSERT_ALWAYS ( iAttributeId, User::Panic(PolicyParserPanic, KErrCorrupt));
+	__ASSERT_ALWAYS ( iDataType, User::Panic(PolicyParserPanic, KErrCorrupt));
+
+	CheckAllElementsL();
+	TElementReserver reserver( Container());
+	
+	_LIT8( DecodeFormat, "<%S %S=\"%S\" %S=\"%S\"/>");	
+	
+	TInt size(25);
+	size += PolicyLanguage::AttributeDesignators::AttributeId[ aLanguage].Length();
+	const TDesC8& attributeId = SelectCorrectValue( aLanguage, *iAttributeId);
+	size += attributeId.Length();
+
+	size += PolicyLanguage::AttributeDesignators::DataType[ aLanguage].Length();
+	const TDesC8& dataType = SelectCorrectValue( aLanguage, *iDataType);
+	size += dataType.Length();
+
+	TPtrC8 ptr;
+	if ( iElementType == ESubjectAttributeDesignator )
+		ptr.Set( PolicyLanguage::AttributeDesignators::SubjectAttributeDesignator[ aLanguage]);
+	else if ( iElementType == EActionAttributeDesignator )
+		ptr.Set( PolicyLanguage::AttributeDesignators::ActionAttributeDesignator[ aLanguage]);
+	else if ( iElementType == EResourceAttributeDesignator )
+		ptr.Set( PolicyLanguage::AttributeDesignators::ResourceAttributeDesignator[ aLanguage]);
+	else 
+		ptr.Set( PolicyLanguage::AttributeDesignators::EnvironmentAttributeDesignator[ aLanguage]);
+	
+	size += 1 * ptr.Length();
+	
+	HBufC8 * hbuf = HBufC8::NewLC( size);
+	
+	hbuf->Des().Format( DecodeFormat, &ptr, 
+									  &PolicyLanguage::AttributeDesignators::AttributeId[ aLanguage], 
+									  &attributeId, 
+									  &PolicyLanguage::AttributeDesignators::DataType[ aLanguage], 
+									  &dataType);
+
+	CleanupStack::Pop( hbuf);
+	
+	reserver.Release();	
+	
+	return hbuf;	
+}
+
+// -----------------------------------------------------------------------------
+// CAttributeDesignator::
+// -----------------------------------------------------------------------------
+//
+
+
+CAttribute * CAttributeDesignator::GetAttributeFromRequestContext( CPolicyProcessor * aRequestContext)
+{
+	__ASSERT_ALWAYS ( iAttributeId, User::Panic(PolicyExecutionPanic, KErrCorrupt));
+
+	CPolicyProcessor::RAttributeList * container = NULL;
+
+	switch ( iElementType)
+	{
+		case ESubjectAttributeDesignator :
+			container = aRequestContext->Subjects();
+		break;
+		case EActionAttributeDesignator :
+			container = aRequestContext->Actions();
+		break;
+		case EResourceAttributeDesignator :
+			container = aRequestContext->Resources();
+		break;
+		case EEnvironmentAttributeDesignator :
+			container = aRequestContext->Environments();
+		break;
+		default:
+		break;
+	}
+
+
+	__ASSERT_ALWAYS ( container, User::Panic(PolicyExecutionPanic, KErrCorrupt));
+
+	for ( TInt i(0); i < container->Count(); i++)
+	{
+		CAttribute * matchAttribute = (*container)[i];
+		__ASSERT_ALWAYS ( matchAttribute, User::Panic(PolicyExecutionPanic, KErrCorrupt));
+		
+		RDEBUG8_2("PolicyEngineServer: Attribute in request context: %S", &matchAttribute->AttributeId());
+		if ( matchAttribute->AttributeId() == *iAttributeId )
+		{
+			return matchAttribute;
+		}
+	}
+	
+	return NULL;
+}
+
+// -----------------------------------------------------------------------------
+// CSubjectAttributeDesignator::
+// -----------------------------------------------------------------------------
+//
+
+
+
+CSubjectAttributeDesignator::CSubjectAttributeDesignator()
+	: CAttributeDesignator()
+{
+	iElementType = ESubjectAttributeDesignator;
+	iElementName.Set( PolicyLanguage::NativeLanguage::AttributeDesignators::SubjectAttributeDesignator);
+
+}
+
+// -----------------------------------------------------------------------------
+// CSubjectAttributeDesignator::
+// -----------------------------------------------------------------------------
+//
+
+CSubjectAttributeDesignator::~CSubjectAttributeDesignator()
+{
+	
+}
+
+// -----------------------------------------------------------------------------
+// CSubjectAttributeDesignator::
+// -----------------------------------------------------------------------------
+//
+	
+CSubjectAttributeDesignator * CSubjectAttributeDesignator::NewL()
+{
+	CSubjectAttributeDesignator * self = new (ELeave) CSubjectAttributeDesignator();
+	return self;
+}
+
+// -----------------------------------------------------------------------------
+// CSubjectAttributeDesignator::
+// -----------------------------------------------------------------------------
+//
+
+
+TBool CSubjectAttributeDesignator::IdentificateType( const TDesC8& aElementName)
+{
+	return ( aElementName == PolicyLanguage::NativeLanguage::AttributeDesignators::SubjectAttributeDesignator);
+}		
+
+// -----------------------------------------------------------------------------
+// CActionAttributeDesignator::
+// -----------------------------------------------------------------------------
+//
+
+
+CActionAttributeDesignator::CActionAttributeDesignator()
+	: CAttributeDesignator()
+{
+	iElementType = EActionAttributeDesignator;
+	iElementName.Set( PolicyLanguage::NativeLanguage::AttributeDesignators::ActionAttributeDesignator);
+
+}
+
+// -----------------------------------------------------------------------------
+// CActionAttributeDesignator::
+// -----------------------------------------------------------------------------
+//
+
+
+CActionAttributeDesignator::~CActionAttributeDesignator()
+{
+	
+}
+
+// -----------------------------------------------------------------------------
+// CActionAttributeDesignator::
+// -----------------------------------------------------------------------------
+//
+
+	
+CElementBase * CActionAttributeDesignator::NewL()
+{
+	CActionAttributeDesignator * self = new (ELeave) CActionAttributeDesignator();
+	return self;
+}
+
+// -----------------------------------------------------------------------------
+// CActionAttributeDesignator::
+// -----------------------------------------------------------------------------
+//
+
+
+TBool CActionAttributeDesignator::IdentificateType( const TDesC8& aElementName)
+{
+	return ( aElementName == PolicyLanguage::NativeLanguage::AttributeDesignators::ActionAttributeDesignator);
+}		
+
+// -----------------------------------------------------------------------------
+// CResourceAttributeDesignator::
+// -----------------------------------------------------------------------------
+//
+
+
+CResourceAttributeDesignator::CResourceAttributeDesignator()
+	: CAttributeDesignator()
+{
+	iElementType = EResourceAttributeDesignator;
+	iElementName.Set( PolicyLanguage::NativeLanguage::AttributeDesignators::ResourceAttributeDesignator);
+
+}
+
+// -----------------------------------------------------------------------------
+// CResourceAttributeDesignator::
+// -----------------------------------------------------------------------------
+//
+
+CResourceAttributeDesignator::~CResourceAttributeDesignator()
+{
+	
+}
+
+// -----------------------------------------------------------------------------
+// CResourceAttributeDesignator::NewL
+// -----------------------------------------------------------------------------
+//
+	
+CElementBase * CResourceAttributeDesignator::NewL()
+{
+	CResourceAttributeDesignator * self = new (ELeave) CResourceAttributeDesignator();
+	return self;
+}
+
+// -----------------------------------------------------------------------------
+// CResourceAttributeDesignator::IdentificateType
+// -----------------------------------------------------------------------------
+//
+
+TBool CResourceAttributeDesignator::IdentificateType( const TDesC8& aElementName)
+{
+	return ( aElementName == PolicyLanguage::NativeLanguage::AttributeDesignators::ResourceAttributeDesignator);
+}		
+
+// -----------------------------------------------------------------------------
+// CEnvironmentAttributeDesignator::CEnvironmentAttributeDesignator
+// -----------------------------------------------------------------------------
+//
+
+CEnvironmentAttributeDesignator::CEnvironmentAttributeDesignator()
+	: CAttributeDesignator()
+{
+	iElementType = EEnvironmentAttributeDesignator;
+	iElementName.Set( PolicyLanguage::NativeLanguage::AttributeDesignators::EnvironmentAttributeDesignator);
+
+}
+
+// -----------------------------------------------------------------------------
+// CEnvironmentAttributeDesignator::~CEnvironmentAttributeDesignator
+// -----------------------------------------------------------------------------
+//
+
+
+CEnvironmentAttributeDesignator::~CEnvironmentAttributeDesignator()
+{
+	
+}
+
+// -----------------------------------------------------------------------------
+// CEnvironmentAttributeDesignator::NewL
+// -----------------------------------------------------------------------------
+//
+
+	
+CElementBase * CEnvironmentAttributeDesignator::NewL()
+{
+	CEnvironmentAttributeDesignator * self = new (ELeave) CEnvironmentAttributeDesignator();
+	return self;
+}
+
+// -----------------------------------------------------------------------------
+// CEnvironmentAttributeDesignator::IdentificateType
+// -----------------------------------------------------------------------------
+//
+
+
+TBool CEnvironmentAttributeDesignator::IdentificateType( const TDesC8& aElementName)
+{
+	return ( aElementName == PolicyLanguage::NativeLanguage::AttributeDesignators::EnvironmentAttributeDesignator);
+}		
+
+// -----------------------------------------------------------------------------
+// CMatchObject::CMatchObject
+// -----------------------------------------------------------------------------
+//
+
+CMatchObject::CMatchObject( const TDesC8& aElementName)
+{
+	if ( aElementName == PolicyLanguage::NativeLanguage::MatchObject::SubjectMatch ) 
+	{
+		iElementType = ESubjectMatch;
+		iElementName.Set( PolicyLanguage::NativeLanguage::MatchObject::SubjectMatch);
+	}
+	else
+	if ( aElementName == PolicyLanguage::NativeLanguage::MatchObject::ResourceMatch) 
+	{
+		iElementType = EResourceMatch;	
+		iElementName.Set( PolicyLanguage::NativeLanguage::MatchObject::ResourceMatch);
+	}
+	else
+	if ( aElementName == PolicyLanguage::NativeLanguage::MatchObject::ActionMatch ) 
+	{
+		iElementType = EActionMatch;
+		iElementName.Set( PolicyLanguage::NativeLanguage::MatchObject::ActionMatch);
+	}
+	else
+	{
+		iElementType = EEnvironmentMatch;		
+		iElementName.Set( PolicyLanguage::NativeLanguage::MatchObject::EnvironmentMatch);
+	}
+	
+	iSaveType = ESubElement;
+}
+
+
+
+// -----------------------------------------------------------------------------
+// CMatchObject::CMatchObject
+// -----------------------------------------------------------------------------
+//
+
+CMatchObject::CMatchObject( TNativeElementTypes aElementType)
+{
+	iElementType = aElementType;
+	
+	switch ( aElementType)
+	{
+		case ESubjectMatch:
+		iElementName.Set( PolicyLanguage::NativeLanguage::MatchObject::SubjectMatch);
+		break;
+		case EResourceMatch:
+		iElementName.Set( PolicyLanguage::NativeLanguage::MatchObject::ResourceMatch);
+		break;
+		case EActionMatch:
+		iElementName.Set( PolicyLanguage::NativeLanguage::MatchObject::ActionMatch);
+		break;
+		case EEnvironmentMatch:
+		iElementName.Set( PolicyLanguage::NativeLanguage::MatchObject::EnvironmentMatch);
+		break;
+	}
+}
+
+// -----------------------------------------------------------------------------
+// CMatchObject::NewL
+// -----------------------------------------------------------------------------
+//
+
+CElementBase * CMatchObject::NewL( TNativeElementTypes aElementType)
+{
+	CMatchObject * self = new (ELeave) CMatchObject(aElementType);
+	return self;
+}
+
+// -----------------------------------------------------------------------------
+// CMatchObject::~CMatchObject
+// -----------------------------------------------------------------------------
+//
+
+CMatchObject::~CMatchObject()
+{
+	delete iMatchId;
+}
+
+// -----------------------------------------------------------------------------
+// CMatchObject::NewL
+// -----------------------------------------------------------------------------
+//
+
+CElementBase * CMatchObject::NewL( const TDesC8& aElementName)
+{
+	CMatchObject * self = new (ELeave) CMatchObject(aElementName);
+	return self;	
+}
+
+// -----------------------------------------------------------------------------
+// CMatchObject::ValidElement
+// -----------------------------------------------------------------------------
+//
+	
+TBool CMatchObject::ValidElement()
+{
+	return iMatchId && iDesignator && iMatchValue;
+}
+
+// -----------------------------------------------------------------------------
+// CMatchObject::AttributeDesignator
+// -----------------------------------------------------------------------------
+//
+
+CAttributeDesignator* CMatchObject::AttributeDesignator()
+{
+	return iDesignator;
+}
+
+// -----------------------------------------------------------------------------
+// CMatchObject::AttributeValue
+// -----------------------------------------------------------------------------
+//
+
+CAttributeValue* CMatchObject::AttributeValue()
+{
+	return iMatchValue;
+}
+
+// -----------------------------------------------------------------------------
+// CMatchObject::MatchId
+// -----------------------------------------------------------------------------
+//
+HBufC8* CMatchObject::MatchId()
+{
+	return iMatchId;
+}
+
+
+// -----------------------------------------------------------------------------
+// CMatchObject::IdentificateType
+// -----------------------------------------------------------------------------
+//
+		
+TBool CMatchObject::IdentificateType( const TDesC8& aElementName)
+{
+	return ( aElementName == PolicyLanguage::NativeLanguage::MatchObject::SubjectMatch ||
+			 aElementName == PolicyLanguage::NativeLanguage::MatchObject::ActionMatch ||
+			 aElementName == PolicyLanguage::NativeLanguage::MatchObject::EnvironmentMatch ||
+			 aElementName == PolicyLanguage::NativeLanguage::MatchObject::ResourceMatch );	
+}
+
+// -----------------------------------------------------------------------------
+// CMatchObject::CheckContainer
+// -----------------------------------------------------------------------------
+//
+
+TBool CMatchObject::CheckMatchObject( const TDesC8& aType, const TDesC8& aAttribute, const TDesC8& aValue)
+{
+	using namespace PolicyLanguage::Constants;
+
+	TBool response = EFalse;
+	
+	if ( (aType == Subject && iElementType == ESubjectMatch) || 
+		 (aType == Action && iElementType == EActionMatch) ||
+		 (aType == Resource && iElementType == EResourceMatch) ||
+		 (aType == Environment && iElementType == EEnvironmentMatch) )
+	{
+
+		
+		__ASSERT_ALWAYS ( iMatchValue, User::Panic(PolicyExecutionPanic, KErrCorrupt));
+		__ASSERT_ALWAYS ( iDesignator, User::Panic(PolicyExecutionPanic, KErrCorrupt));
+	
+		response = ETrue;
+	
+		if ( aValue != Any)
+		{
+			if ( iMatchValue->Data()->Value() != aValue )
+			{
+				response = EFalse;
+			}
+		}
+		
+		if ( response && iDesignator->GetAttributeid() != aAttribute)
+		{
+			response = EFalse;
+		}
+	}
+	
+	return response;
+}
+
+// -----------------------------------------------------------------------------
+// CMatchObject::AddAttributeL
+// -----------------------------------------------------------------------------
+//
+
+
+
+
+void CMatchObject::AddAttributeL( CPolicyParser *aParser, const TDesC8& aName, const TDesC8& aValue)
+{	
+	if ( aName == PolicyLanguage::NativeLanguage::MatchObject::MatchId )
+	{
+		if ( aParser)
+		{
+			aParser->CheckFunctionIdL( iElementType, aValue);
+		}
+		iMatchId = aValue.AllocL();
+	}
+	else
+	{
+		if ( aParser)
+		{
+			aParser->HandleErrorL( ParserErrors::UnexpectedAttribute, aName );
+		}
+	}
+}
+
+// -----------------------------------------------------------------------------
+// CMatchObject::AddElementL
+// -----------------------------------------------------------------------------
+//
+
+void CMatchObject::AddElementL( CPolicyParser *aParser, CElementBase * aElement)
+{
+	if ( aElement->ElementType() == ESubjectAttributeDesignator ||
+		 aElement->ElementType() == EActionAttributeDesignator ||
+		 aElement->ElementType() == EResourceAttributeDesignator ||
+		 aElement->ElementType() == EEnvironmentAttributeDesignator)
+	{
+		if ( aParser )
+		{
+			aParser->HandleErrorL( iDesignator, ParserErrors::UnexpectedElement, aParser->ActiveElementName());	
+		}
+		iDesignator = (CAttributeDesignator*) aElement;
+		AddToElementListL( aElement, ETrue);
+	}
+	else if ( aElement->ElementType() == EAttributeValue)
+	{
+		if ( aParser )
+		{
+			aParser->HandleErrorL( iMatchValue, ParserErrors::UnexpectedElement, aParser->ActiveElementName());	
+		}
+		iMatchValue = (CAttributeValue*) aElement;
+		AddToElementListL( aElement, ETrue);
+	}
+	else
+	{
+		aParser->HandleErrorL( ParserErrors::UnexpectedElement, aParser->ActiveElementName());
+	}
+};
+
+// -----------------------------------------------------------------------------
+// CMatchObject::
+// -----------------------------------------------------------------------------
+//
+
+HBufC8 * CMatchObject::DecodeElementL( const TLanguageSelector &aLanguage, const TDecodeMode &aMode )
+{
+	RDEBUG("Decode MatchObject element");
+
+	__ASSERT_ALWAYS ( iDesignator, User::Panic(PolicyParserPanic, KErrCorrupt));
+	__ASSERT_ALWAYS ( iMatchValue, User::Panic(PolicyParserPanic, KErrCorrupt));
+	__ASSERT_ALWAYS ( iMatchId, User::Panic(PolicyParserPanic, KErrCorrupt));
+
+	CheckAllElementsL();
+	TElementReserver reserver( Container());
+
+	
+	_LIT8( DecodeFormat, "<%S %S=\"%S\"> %S %S </%S>");	
+	
+	TInt size(25);
+	size += PolicyLanguage::MatchObject::MatchId[ aLanguage].Length();
+	const TDesC8& matchId = SelectCorrectValue( aLanguage, *iMatchId);
+	size += matchId.Length();
+
+	TPtrC8 ptr;
+	if ( iElementType == ESubjectMatch )
+		ptr.Set( PolicyLanguage::MatchObject::SubjectMatch[ aLanguage]);
+	else if ( iElementType == EActionMatch )
+		ptr.Set( PolicyLanguage::MatchObject::ActionMatch[ aLanguage]);
+	else if ( iElementType == EResourceMatch )
+		ptr.Set( PolicyLanguage::MatchObject::ResourceMatch[ aLanguage]);
+	else 
+		ptr.Set( PolicyLanguage::MatchObject::EnvironmentMatch[ aLanguage]);
+	
+	size += 2 * ptr.Length();
+	
+	HBufC8 * matchValue = DecodeElementOrIdL( aLanguage, iMatchValue, aMode);//EFullMode);
+	
+	CleanupStack::PushL( matchValue);
+	
+	size += matchValue->Length();
+	
+
+	HBufC8 * designator = DecodeElementOrIdL( aLanguage, iDesignator, aMode); //EFullMode);
+
+	CleanupStack::PushL( designator);
+		
+	size += designator->Length();
+	
+	HBufC8 * hbuf = HBufC8::NewLC( size);
+	
+	hbuf->Des().Format( DecodeFormat, &ptr, 
+									  &PolicyLanguage::MatchObject::MatchId[ aLanguage],
+									  &matchId, 
+									  matchValue, 
+									  designator, 
+									  &ptr);
+
+	CleanupStack::Pop( hbuf);
+	CleanupStack::PopAndDestroy( 2, matchValue);
+	
+	
+	reserver.Release();	
+	
+	return hbuf;
+}
+
+// -----------------------------------------------------------------------------
+// CMatchObject::MatchL
+// -----------------------------------------------------------------------------
+//
+	
+	
+TMatchResponse CMatchObject::MatchL( CPolicyProcessor* aPolicyProcessor)
+{
+#ifndef __POLICY_BASE_CREATOR_TOOL
+
+	RDEBUG("PolicyEngineServer: CMatchObject::MatchL");
+
+	__ASSERT_ALWAYS ( iDesignator, User::Panic(PolicyExecutionPanic, KErrCorrupt));
+	__ASSERT_ALWAYS ( iMatchValue, User::Panic(PolicyExecutionPanic, KErrCorrupt));
+
+	
+	TElementReserver designatorReserver( iDesignator);
+	TElementReserver matchReserver( iMatchValue);
+
+	#ifdef _DEBUG
+		switch ( iElementType)
+		{
+			case ESubjectMatch:
+				RDEBUG8_2("PolicyEngineServer: SubjectMatch - AttrId: %S", &iDesignator->GetAttributeid());
+			break;
+			case EActionMatch:
+				RDEBUG8_2("PolicyEngineServer: ActionMatch - AttrId: %S", &iDesignator->GetAttributeid());
+			break;
+			case EResourceMatch:
+				RDEBUG8_2("PolicyEngineServer: ResourceMatch - AttrId: %S", &iDesignator->GetAttributeid());
+			break;
+			default:
+				RDEBUG8_2("PolicyEngineServer: EnvinromentMatch - AttrId: %S", &iDesignator->GetAttributeid());
+			break;
+		}
+	#endif 
+
+	CAttribute * requestAttribute = iDesignator->GetAttributeFromRequestContext( aPolicyProcessor); 	
+
+	TMatchResponse response = EUnMatch;
+		
+	if ( requestAttribute)
+	{
+		if ( iDesignator->GetDataType() != requestAttribute->AttributeType() )
+		{
+			RDEBUG("PolicyEngineServer: Datatypes doesn't match between request and policy attributes -> INDETERMINATE!");
+			response =  EIndeterminate;
+		}
+		else
+		{
+			if ( aPolicyProcessor->MatchFunctionL( *iMatchId, iMatchValue->Data(), requestAttribute->AttributeValue()->Data()))
+			{
+				RDEBUG8_3("PolicyEngineServer: MATCH: %S == %S", &iMatchValue->Data()->Value(), &requestAttribute->AttributeValue()->Data()->Value());
+				response =  EMatch;
+			}
+			else
+			{
+				RDEBUG8_3("PolicyEngineServer: UNMATCH: %S != %S", &iMatchValue->Data()->Value(), &requestAttribute->AttributeValue()->Data()->Value());
+			}
+		}
+	}
+	else
+	{
+		
+	}	
+	
+	matchReserver.Release();
+	designatorReserver.Release();
+	return response;
+
+#endif// __POLICY_BASE_CREATOR_TOOL
+}
+
+
+// -----------------------------------------------------------------------------
+// CMatchObject::AddIdElementL
+// -----------------------------------------------------------------------------
+//
+
+void CMatchObject::AddIdElementL( CElementBase * aElement)
+{
+	__ASSERT_ALWAYS ( aElement, User::Panic(PolicyParserPanic, KErrCorrupt));
+	
+	switch ( aElement->ElementType())
+	{
+		case ESubjectAttributeDesignator:
+		case EActionAttributeDesignator:
+		case EResourceAttributeDesignator:
+		case EEnvironmentAttributeDesignator:
+			iDesignator = (CAttributeDesignator*) aElement;
+		break;
+		
+		case EAttributeValue :
+			iMatchValue = (CAttributeValue*) aElement;
+		break;
+	}
+
+	AddToElementListL( aElement, EFalse);
+}
+
+// -----------------------------------------------------------------------------
+// CDescription::
+// -----------------------------------------------------------------------------
+//
+
+CDescription::CDescription()
+{
+	iElementType = EDescription;
+	iElementName.Set( PolicyLanguage::NativeLanguage::Description::Description);
+}
+
+// -----------------------------------------------------------------------------
+// CDescription::
+// -----------------------------------------------------------------------------
+//
+
+CDescription::~CDescription()
+{
+	delete iDescription;	
+}
+
+// -----------------------------------------------------------------------------
+// CDescription::
+// -----------------------------------------------------------------------------
+//
+	
+CElementBase * CDescription::NewL()
+{
+	return new (ELeave) CDescription();
+}
+
+// -----------------------------------------------------------------------------
+// CDescription::
+// -----------------------------------------------------------------------------
+//
+		
+TBool CDescription::IdentificateType( const TDesC8& aElementName)
+{
+	return aElementName == PolicyLanguage::NativeLanguage::Description::Description;
+}
+
+// -----------------------------------------------------------------------------
+// CDescription::
+// -----------------------------------------------------------------------------
+//
+	
+HBufC8 * CDescription::DecodeElementL( const  TLanguageSelector &aLanguage, const TDecodeMode &/*aMode*/  )
+{
+	RDEBUG("PolicyEngineServer: Decode Description element");
+
+
+	__ASSERT_ALWAYS ( iDescription, User::Panic(PolicyParserPanic, KErrCorrupt));
+	
+	_LIT8( DecodeFormat, "<%S>%S</%S>");	
+	
+	TInt size(5);
+	TPtrC8 ptr = PolicyLanguage::Description::Description[ aLanguage];
+	size += ptr.Length() * 2;
+
+	size += iDescription->Length();
+	
+	HBufC8 * hbuf = HBufC8::NewLC( size);
+	hbuf->Des().Format( DecodeFormat, &ptr, iDescription, &ptr);
+	CleanupStack::Pop( hbuf);
+	
+	return hbuf;
+}
+
+// -----------------------------------------------------------------------------
+// CDescription::
+// -----------------------------------------------------------------------------
+//
+		
+void CDescription::AddContentL( CPolicyParser */*aParser*/, const TDesC8& aName)
+{
+	if ( iDescription )
+	{
+		iDescription = iDescription->ReAllocL( iDescription->Length() + aName.Length());
+		iDescription->Des().Append( aName);
+	}
+	else
+	{
+		iDescription = aName.AllocL();
+	}
+};
+
+// -----------------------------------------------------------------------------
+// CDescription::
+// -----------------------------------------------------------------------------
+//
+
+HBufC8 * CDescription::DescriptionText()
+{
+	return iDescription;
+}
+
+// -----------------------------------------------------------------------------
+// CDescription::
+// -----------------------------------------------------------------------------
+//
+
+TBool CDescription::ValidElement()
+{
+	return ETrue;
+}
+