/*
* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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: 
* This file contains the implementation for CAuthExpression which is only visible
* to implementation, and not the the client code.
*
*/


/**
 @file 
 @released
 @internalComponent
*/
 
#ifndef AUTHEXPRESSION_IMPL_H
#define AUTHEXPRESSION_IMPL_H

#include <s32buf.h>
#include <authserver/authexpression.h>

namespace AuthServer {

// constants and operators used for processing authentication expression.

_LIT(KAuthOpAnd,"&");
_LIT(KAuthOpOr,"|");
_LIT(KAuthBiometric, "Biometric");
_LIT(KAuthDefault, "Default");
_LIT(KAuthKnowledge, "Knowledge");
_LIT(KAuthToken, "Token");
_LIT(KAuthPerformance, "Performance");
_LIT(KOpenBracket, "(");
_LIT(KCloseBracket, ")");
const TInt KMaxBufferSize = 2048;
    
class TSizeStream : public MStreamBuf
/**
	This subclass of MStreamBuf is used with
	RWriteStream to count how many bytes are
	required to externalize an object.
 */
	{
public:
	inline TSizeStream();
	inline TInt Size() const;

	// override MStreamBuf
	IMPORT_C virtual void DoWriteL(const TAny* /* aPtr */, TInt aLength);

private:
	/** Accumulated stream length in bytes. */
	TInt iSize;
	};


class CAuthExpressionImpl : public CAuthExpression
/**
	This class, which is not visible to clients,
	defines the variables and functions which are
	used by authentication expressions.
	
	Clients should use the CAuthExpression base class
	which provides type safety but provides no implementation,
	so authentication expressions can be re-implemented
	later without breaking BC.

	@internalComponent
 */
	{
public:
	/**
		The type of expression represented by an instance
		of this object, namely a plugin type, a plugin ID,
		or a complex AND expression, OR expression or a 
		NULL expression.
	 */
	enum TType {EPluginType, EPluginId, EAnd, EOr, ENull};
		
	CAuthExpressionImpl(TAuthPluginType aType);
	CAuthExpressionImpl(TPluginId aPluginId);
	CAuthExpressionImpl();
	CAuthExpressionImpl(TType aType, CAuthExpressionImpl* aLeft, CAuthExpressionImpl* aRight);

	IMPORT_C static CAuthExpressionImpl* NewL(RReadStream& aReadStream);

	virtual ~CAuthExpressionImpl();

	// implement CAuthExpression
	virtual void ExternalizeL(RWriteStream& aWriteStream) const;
	
	IMPORT_C static CAuthExpression* CreateAuthExprObjectL(const TDesC& aStrengthAliasString);
	
	IMPORT_C static void InsertSpaceBetweenOperatorsL(const TDesC& aAliasStringToBeProcessed, RBuf& aResultantAliasString);
	
	inline TType Type() const;
	inline const CAuthExpressionImpl* Left() const;
	inline const CAuthExpressionImpl* Right() const;
	inline TAuthPluginType PluginType() const;
	inline TPluginId PluginId() const;
	inline CAuthExpressionImpl* Parent() const;

private:
	/**
		Current authentication expression version.
		This is embedded in the externalized expression
		so the server can reject the expression if it
		uses an unsupported version.
	 */
	static const TInt KVersion;
	void Externalize2L(RWriteStream& aWriteStream) const;
	static CAuthExpressionImpl* New2L(RReadStream& aReadStream);
	static CAuthExpression* CreateAuthExpressionL(const TDesC& aAliasString);
	static CAuthExpression* CreateAuthExpressionL(RPointerArray<CAuthExpression>& aAuthExprArray, TPtrC aOperator);
	static CAuthExpression* EvaluateAliasStringL(const RBuf& aStrengthAliasString);
	
	
private:
	/**
		This expression's parent node.  This value is
		used to navigate the expression tree during
		evaluation.
	 */
	CAuthExpressionImpl* iParent;
	
	/** This expression's type. */
	TType iType;
	
	class TBinaryComb
	/**
		This class contains pointers to the left and
		right subexpressions when this expression is
		an AND or an OR.
	 */
		{
	public:
		/** Left subexpression.  This cannot be NULL. */
		CAuthExpressionImpl* iLeft;
		/** Right subexpression.  This cannot be NULL. */
		CAuthExpressionImpl* iRight;
		};

	union
		{
		/** This field is valid iff iType == EPluginType. */
		TAuthPluginType iPluginType;
		/** This field is valid iff iType == EPluginId. */
		TPluginId iPluginId;
		/** This field is valid iff iType == EAnd or iType == EOr. */
		TBinaryComb iComb;
		};
		
private:
	// Invariant and Panic are defined, but only as stub
	// functions for release mode.

	enum TPanic
	/**
		In debug builds the current thread can be halted
		with panic category "AUTHEXPR" and one of the
		following reasons to indicate that the object has
		become corrupt or that a caller has supplied an
		invalid argument to one of this class' functions.
	 */
		{
		ECtTyInvariant = 0x10,
		ECtIdInvariant = 0x20,
		ECt2BadComb = 0x30, ECt2NullLeft, ECt2NullRight, ECt2Invariant,
		ETyAInvariant = 0x40,
		ELfInvariant = 0x50, ELfNotComplex,
		ERgInvariant = 0x60, ERgNotComplex,
		EPTyInvariant = 0x70, EPTyNotPluginType,
		EPIdInvariant = 0x80, EPIdNotPluginId,
		EPPrInvariant = 0x90,
		EExtInvariant = 0xa0
		};
		

	IMPORT_C TBool Invariant() const;
	IMPORT_C static void Panic(TPanic aPanic);
	};

}	// namespace AuthServer {

#include "authexpression_impl.inl"

#endif	// #ifndef AUTHEXPRESSION_IMPL_H