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


#ifndef ELEMENTS_HEADER_
#define ELEMENTS_HEADER_

// INCLUDES

#include "ElementBase.h"
#include "XACMLconstants.h"
#include "RequestContext.h"
#include "PolicyStorage.h"

#include <e32base.h>

// CONSTANTS
// MACROS
// FORWARD DECLARATIONS

class CAttributeDesignator;
class CAttributeValue;
class CPolicyProcessor;
class CMatchObject;
class CItemContainer;
class CTarget;

// DATA TYPES

typedef RArray<HBufC*> RAttributeValuesList;

// FUNCTION PROTOTYPES
// CLASS DECLARATION

/*
class TUnionTarget
{
	public:
		TUnionTarget( CPolicyStorage * aPolicyStorage);
		~TUnionTarget();
		void AddTargetElementsL( CElementBase * aElement);
		
		RMatchObjectArray * GetSubjectAttributes();
		RMatchObjectArray * GetResourceAttributes();
		RMatchObjectArray * GetActionAttributes();
		RMatchObjectArray * GetEnviromentAttributes();
		
		CMatchObject * FindSubjectAttribute( const TDesC8 &aAttributeId);
		CMatchObject * FindActionAttribute( const TDesC8 &aAttributeId);
		CMatchObject * FindResourceAttribute( const TDesC8 &aAttributeId);
		CMatchObject * FindEnvironmentAttribute( const TDesC8 &aAttributeId);
	
	private:
		CMatchObject * FindAttribute( const TDesC8 &aAttributeId, RMatchObjectArray *aMatchObjectArray);
		
	private:		
		CPolicyStorage * iPolicyStorage;
		TElementReserver iReserver;
		
		RMatchObjectArray iSubjectAttributes;
		RMatchObjectArray iResourceAttributes;
		RMatchObjectArray iActionAttributes;
		RMatchObjectArray iEnvironmentAttributes;
};*/

class RContentBuilder : public RPointerArray<HBufC8>
{
	public:
		RContentBuilder();
	
		void AddContentL( HBufC8 * aBuffer);
		HBufC8 * ContentL();
		HBufC8 * ContentLC();
		
		void Close();		
	private:
		TInt iSize;
};

class CApply : public CElementBase
{
	public:
			CApply();
			~CApply();
		
			static CApply * NewL();
			static TBool IdentificateType( const TDesC8& aElementName);

			HBufC8 * DecodeElementL( const  TLanguageSelector &aLanguage, const TDecodeMode &aMode);

			void AddAttributeL( CPolicyParser *aParser, const TDesC8& aName, const TDesC8& aValue);
			void AddElementL( CPolicyParser *aParser, CElementBase * aElement);
	
			void AddIdElementL( CElementBase * aElement);	
			virtual TBool ValidElement();
		
			CAttributeValue * ApplyValueL( CPolicyProcessor* aPolicyProcessor);
			
			const TPtrC8 ReturnDataType();
		
		private:
			void ConstructL();
			HBufC8 * iFunctionId;
			CAttributeValue * iResponseValue;			
};

class CCondition : public CElementBase
{
	public:
		CCondition();
		~CCondition();
		
		static CCondition * NewL();
		static TBool IdentificateType( const TDesC8& aElementName);

		HBufC8 * DecodeElementL( const  TLanguageSelector &aLanguage, const TDecodeMode &aMode);

		void AddElementL( CPolicyParser *aParser, CElementBase * aElement);
	
		void AddIdElementL( CElementBase * aElement);	
		virtual TBool ValidElement();
		
		TMatchResponse ConditionValueL( CPolicyProcessor* aPolicyProcessor);
	private:
		CElementBase * iExpression;
};


class CPolicySet : public CElementBase
{
	public:
		CPolicySet();
		virtual ~CPolicySet();

		static CPolicySet * NewL();
		static TBool IdentificateType( const TDesC8& aElementName);

		HBufC8 * DecodeElementL( const  TLanguageSelector &aLanguage, const TDecodeMode &aMode);

		void AddAttributeL( CPolicyParser *aParser, const TDesC8& aName, const TDesC8& aValue);
		void AddElementL( CPolicyParser *aParser, CElementBase * aElement);
	
		TMatchResponse MatchL( CPolicyProcessor* aPolicyProcessor);
		void AddIdElementL( CElementBase * aElement);	
		
		virtual TBool ValidElement();
	private:
		HBufC8 * iPolicySetId;
		HBufC8 * iPolicyCompiningAlg;
		CElementBase * iTarget;
		CElementBase * iDescription;
};

class CPolicy : public CElementBase
{
	public:
		CPolicy();
		virtual ~CPolicy();

		static CPolicy * NewL();
		static TBool IdentificateType( const TDesC8& aElementName);

		HBufC8 * DecodeElementL( const  TLanguageSelector &aLanguage, const TDecodeMode &aMode);

		void AddAttributeL( CPolicyParser *aParser, const TDesC8& aName, const TDesC8& aValue);
		void AddElementL( CPolicyParser *aParser, CElementBase * aElement);
	
		TMatchResponse MatchL( CPolicyProcessor* aPolicyProcessor);
		void AddIdElementL( CElementBase * aElement);	

		virtual TBool ValidElement();
		
	private:
		HBufC8 * iPolicyId;
		HBufC8 * iRuleCompiningAlg;
		CElementBase * iDescription;
		CElementBase * iTarget;
};

class CRule : public CElementBase
{
	public:
		CRule();
		virtual ~CRule();
		
		static CRule * NewL();
		static TBool IdentificateType( const TDesC8& aElementName);
			
		HBufC8 * DecodeElementL( const  TLanguageSelector &aLanguage, const TDecodeMode &aMode);

		TMatchResponse MatchL( CPolicyProcessor* aPolicyProcessor);
		TMatchResponse Effect();
		
		const TDesC8& EffectValue();
		CTarget* GetTarget();

		void AddIdElementL( CElementBase * aElement);
		void SetRuleIdL( const TDesC8& aName);
		void SetEffectL( const TDesC8& aEffect);

		virtual TBool ValidElement();
		void AddAttributeL( CPolicyParser *aParser, const TDesC8& aName, const TDesC8& aValue);
		void AddElementL( CPolicyParser *aParser, CElementBase * aElement);
	private: 
		
	private:
		CElementBase * iDescription;
		HBufC8 * iEffect;
		HBufC8 * iRuleId;
		
		CElementBase * iTarget;
		CElementBase * iCondition;
};

class CTarget : public CElementBase
{
	public:
		CTarget();
		virtual ~CTarget();

		static CTarget * NewL();
		static TBool IdentificateType( const TDesC8& aElementName);
			
		HBufC8 * DecodeElementL( const  TLanguageSelector &aLanguage, const TDecodeMode &aMode);
		TMatchResponse MatchL( CPolicyProcessor* aPolicyProcessor);
		void AddIdElementL( CElementBase * aElement);

		virtual TBool ValidElement();
		
		void GetMatchContainersL( RMatchObjectArray& aMatchContainer );
		
		//Parsing functions
		void AddElementL( CPolicyParser *aParser, CElementBase * aElement);
	private:	
		
	private:
		CElementBase * iSubjects;
		CElementBase * iActions;
		CElementBase * iResources;
		CElementBase * iEnvironments;			
};

class CItemContainer : public CElementBase
{
	public:
		virtual ~CItemContainer();
		
		HBufC8 * DecodeElementL( const  TLanguageSelector &aLanguage, const TDecodeMode &aMode  );
		TMatchResponse MatchL( CPolicyProcessor* aPolicyProcessor);
		void AddIdElementL( CElementBase * aElement);
		
		virtual TBool ValidElement();
		
		void GetMatchContainersL( RMatchObjectArray& aMatchContainer );
	protected:
		CItemContainer();

	private:
		void AddElementL( CPolicyParser *aParser, CElementBase * aElement);

	protected:
		enum TBooleanType
		{
			EOrBoolean,
			EAndBoolean
		};
	
		TNativeElementTypes iAllowedType;
		TBooleanType iBooleanType;
};

class CSubjects : public CItemContainer
{
	public:
		CSubjects();
		virtual ~CSubjects();
		
		static CSubjects * NewL();
		static TBool IdentificateType( const TDesC8& aElementName);
	private:
};


class CSubject : public CItemContainer
{
	public:
		CSubject();
		virtual ~CSubject();
		
		static CSubject * NewL();
		static TBool IdentificateType( const TDesC8& aElementName);
	private:
};

class CActions : public CItemContainer
{
	public:
		CActions();
		virtual ~CActions();
		
		static CElementBase * NewL();
		static TBool IdentificateType( const TDesC8& aElementName);
	private:
};


class CAction : public CItemContainer
{
	public:
		CAction();
		virtual ~CAction();
		
		static CElementBase * NewL();
		static TBool IdentificateType( const TDesC8& aElementName);
	private:
};

class CResources : public CItemContainer
{
	public:
		CResources();
		virtual ~CResources();
		
		static CElementBase * NewL();
		static TBool IdentificateType( const TDesC8& aElementName);
	private:
};


class CResource : public CItemContainer
{
	public:
		CResource();
		virtual ~CResource();
		
		static CElementBase * NewL();
		static TBool IdentificateType( const TDesC8& aElementName);
	private:
};

class CEnvironments : public CItemContainer
{
	public:
		CEnvironments();
		virtual ~CEnvironments();
		
		static CElementBase * NewL();
		static TBool IdentificateType( const TDesC8& aElementName);
	private:
};


class CEnvironment : public CItemContainer
{
	public:
		CEnvironment();
		virtual ~CEnvironment();
		
		static CElementBase * NewL();
		static TBool IdentificateType( const TDesC8& aElementName);
	private:
};




class CAttribute : public CElementBase
{
	public:
		CAttribute();
		virtual ~CAttribute();
		
		static CAttribute * NewL( const TDesC8& aAttributeId, const TDesC8& aAttributeValue, const TDesC8& aDataType);
		static CAttribute * NewL( const TDesC8& aAttributeId, const TBool& aAttributeValue);
		void ConstructL( const TDesC8& aAttributeId, const TDesC8& aAttributeValue, const TDesC8& aDataType);
	
	
		CAttributeValue * AttributeValue();
		TDesC8& AttributeId();
		TDesC8& AttributeType();	
	
	private:
		CAttributeValue * iAttributeValue;
		HBufC8 * iAttributeId;
		HBufC8 * iDataType;
};

class CAttributeDesignator : public CElementBase
{
	public:
		CAttributeDesignator();
		virtual ~CAttributeDesignator();
		static CElementBase * NewL( TNativeElementTypes aType);
		
		HBufC8 * DecodeElementL( const  TLanguageSelector &aLanguage, const TDecodeMode &aMode  );
		
		TDesC8& GetAttributeid();
		TDesC8& GetDataType();
		
		CAttribute * GetAttributeFromRequestContext( CPolicyProcessor * iRequestContext);
		
		virtual TBool ValidElement();
		void AddAttributeL( CPolicyParser *aParser, const TDesC8& aName, const TDesC8& aValue);
	private:	
	protected:		
		HBufC8 * iAttributeId;
		HBufC8 * iDataType;
};

class CSubjectAttributeDesignator : public CAttributeDesignator
{
	public:
		CSubjectAttributeDesignator();
		virtual ~CSubjectAttributeDesignator();

		static CSubjectAttributeDesignator * NewL();
		static TBool IdentificateType( const TDesC8& aElementName);
		
	private:
};

class CActionAttributeDesignator : public CAttributeDesignator
{
	public:
		CActionAttributeDesignator();
		virtual ~CActionAttributeDesignator();

		static CElementBase * NewL();
		static TBool IdentificateType( const TDesC8& aElementName);
		
	private:
};

class CResourceAttributeDesignator : public CAttributeDesignator
{
	public:
		CResourceAttributeDesignator();
		virtual ~CResourceAttributeDesignator();

		static CElementBase * NewL();
		static TBool IdentificateType( const TDesC8& aElementName);
		
	private:
};

class CEnvironmentAttributeDesignator : public CAttributeDesignator
{
	public:
		CEnvironmentAttributeDesignator();
		virtual ~CEnvironmentAttributeDesignator();

		static CElementBase * NewL();
		static TBool IdentificateType( const TDesC8& aElementName);
		
	private:
};


class CMatchObject : public CElementBase
{
	public:
		CMatchObject( TNativeElementTypes aElementType);
		CMatchObject( const TDesC8& aElementName);
		virtual ~CMatchObject();
	
		void AddAttributeL( CPolicyParser *aParser, const TDesC8& aName, const TDesC8& aValue);
		void AddElementL( CPolicyParser *aParser, CElementBase * aElement);
	
		static CElementBase * NewL( const TDesC8& aElementName);
		static CElementBase * NewL( TNativeElementTypes aElementType);
		
		
		static TBool IdentificateType( const TDesC8& aElementName);
		HBufC8 * DecodeElementL( const  TLanguageSelector &aLanguage, const TDecodeMode &aMode  );
		
		CAttributeDesignator* AttributeDesignator();
		CAttributeValue* AttributeValue();
		HBufC8* MatchId();
		
		TMatchResponse MatchL( CPolicyProcessor* aPolicyProcessor);

		TBool CheckMatchObject( const TDesC8& aType, const TDesC8& aAttribute, const TDesC8& aValue);
		

		void AddIdElementL( CElementBase * aElement);		
		virtual TBool ValidElement();
	private: 
		HBufC8 * iMatchId;
		
		CAttributeDesignator* iDesignator;
		CAttributeValue* iMatchValue;
};


class CDescription : public CElementBase
{
	public:
		CDescription();
		virtual ~CDescription();
	
		static CElementBase * NewL();
		
		static TBool IdentificateType( const TDesC8& aElementName);
		HBufC8 * DecodeElementL( const  TLanguageSelector &aLanguage, const TDecodeMode &aMode  );
		HBufC8 * DescriptionText();
		
		void AddContentL( CPolicyParser *aParser, const TDesC8& aName);

		virtual TBool ValidElement();
	private: 
		HBufC8 * iDescription;
		
};


#endif