/*

* Copyright (c) 2004-2006 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:     This file contains definition of the SISpeechRecognitionDataDevASR structure and API.

*

*/

#ifndef __SRSIDATA_DEVASR_H__

#define __SRSIDATA_DEVASR_H__

//  INCLUDES

#include <nsssispeechrecognitiondatacommon.h>

// FORWARD DECLARATION

class CSILexicon;

class CSICompiledGrammar;

// CLASS DECLARATION

/**

*  Class to encapsulate a user defined parameters

*

*  @lib nsssispeechrecognitiondata.lib

*  @since 2.8

*/

class CSIParameters : public CBase

	{

	public: // Constructors and destructor

		/**

		* Destructor.

        */

		IMPORT_C virtual ~CSIParameters();

		/**

		* Two-phased constructor.

		*/

		IMPORT_C static CSIParameters* NewL();

		IMPORT_C static CSIParameters* NewLC();

	public: // New functions

		/**

        * Use to set an internal parameter.

        * @since 2.8

		* @param aParameterIndex Parameter index

		* @param aParameter Parameter value

        * @return None.

        */ 

		IMPORT_C virtual void SetParameterL( const TInt aParameterID, const TInt aParameterValue );

		/**

        * Use to retrieve an internal parameter.

        * @since 2.8

		* @param aParameterIndex Parameter index

        * @return Parameter value.

        */ 

		IMPORT_C virtual TInt ParameterL( const TInt aParameterID ) const;

		/**

        * Internalize to a data stream

        * @since 2.8

		* @param aStream Data stream

        * @return  None

        */ 

		IMPORT_C virtual void InternalizeL(RReadStream& aStream );

		/**

        * Externalize from a data stream

        * @since 2.8

		* @param None

        * @return  aStream Data stream

        */ 

		IMPORT_C virtual void ExternalizeL(RWriteStream& aStream ) const;

        /**

        * Returns all set parameters and their values.

        * @since 2.8

        * @param "RArray<TInt>& aParameterIDs" This array will contain parameter IDs after call.

        * @param "RArray<TInt>& aParameterValues" This array will contain parameter values after call.

        */

        IMPORT_C virtual void ListParametersL( RArray<TInt>& aParameterIDs, RArray<TInt>& aParameterValues ) const;

	protected:

		IMPORT_C virtual void ConstructL();

		IMPORT_C CSIParameters();

	private:

		RArray<TInt> iParameterIDs;

		RArray<TInt> iParameterValues;	

	};

/**

*  Class to encapsulate a Speaker Independent Rule variant

*

*  @lib nsssispeechRecognitionData.lib

*  @since 2.8

*/

class CSIRuleVariant : public CSIParameters

	{

	public: // Constructors and destructor

		/**

		* Destructor.

        */

		IMPORT_C virtual ~CSIRuleVariant();

        /**

        * Two-phased constructor.

        */

		IMPORT_C static CSIRuleVariant* NewL( const TSIRuleVariantID aRuleVariantID, 

											  const TSILexiconID aLexiconID);

	    IMPORT_C static CSIRuleVariant* NewLC( const TSIRuleVariantID aRuleVariantID, 

											  const TSILexiconID aLexiconID);

	public: // New functions

		/**

        * Use to get the pronunciation Ids.

        * @since 2.8

		* @param None.

        * @return Pronunciation identifier.

        */ 

		IMPORT_C virtual void GetPronunciationIDsL( TSIPronunciationIDSequence& aPronunciationIDs ) const;

		/**

        * Use to set the pronunciation Ids.

        * @since 2.8

		* @param Pronunciation identifier .

        */ 

		IMPORT_C virtual void SetPronunciationIDsL( const TSIPronunciationIDSequence& aPronunciationIDs );

		/**

        * Get Language of the rule variant

        * @since 2.8

        * @return Language of the rule variant

        */ 

		IMPORT_C virtual TLanguage Language() const;  

		/**

        * Set Language of the rule variant

        * @since 2.8

        * @param Language of the rule variant

        * @return None

        */ 

		IMPORT_C virtual void SetLanguage(TLanguage aLanguage);

		/**

        * Use to retrieve the lexicon Id.

        * @since 2.8

		* @param None.

        * @return Lexicon identifier.

        */ 

		IMPORT_C virtual TSILexiconID LexiconID() const;

		/**

        * Use to retrieve the rule variant Id.

        * @since 2.8

        * @param None.

        * @return Rule identifier.

        */ 

		IMPORT_C virtual TSIRuleVariantID RuleVariantID() const;

	protected:

		IMPORT_C virtual void ConstructL();

		IMPORT_C CSIRuleVariant( const TSIRuleVariantID aRuleVariantID, 

			const TSILexiconID aLexiconID );

	private:

		TSIRuleVariantID iRuleVariantID;

		TSIPronunciationIDSequence iPronunciationIDs;

		TSILexiconID iLexiconID;

		TLanguage iLanguage;

		TInt* iParameterArray;

		TInt iNParameters;

		TAny* iReserved;

	};

/**

*  Class to encapsulate a Speaker Independent Rule

*

*  @lib nsssispeechrecognitiondata.lib

*  @since 2.8

*/

class CSIRule : public CBase

	{

	public:// Constructors and destructor

		   /**

		   * Destructor.

        */

		IMPORT_C virtual ~CSIRule();

        /**

        * Two-phased constructor.

        */

		IMPORT_C static CSIRule* NewL( const TSIRuleID aRuleID );

	    IMPORT_C static CSIRule* NewLC( const TSIRuleID aRuleID );

	public: // New functions

		/**

			* Use to retrieve the rule Id.

			* @since 2.8

			* @param None.

			* @return Rule identifier.

        */ 

		IMPORT_C virtual TSIRuleID RuleID() const;

	/**

		* Use to retrieve number of rule variants.

		* @since 2.8

		* @param None.

		* @return Number of rule variants.

       */

		IMPORT_C virtual TInt Count() const;

 		/**

		* Use to retrieve the rule variant based on index.

		* @since 2.8

		* @param aIndex Index of rule variant.

		* @return Rule variant.

        */

		IMPORT_C virtual CSIRuleVariant& AtL(TInt aIndex) const;	

			/**

		* Use to add new rule variant.

		* @since 2.8

		* @param aRuleVariant New rule variant.

		* @return None.

        */

		IMPORT_C virtual void AddL(CSIRuleVariant* aRuleVariant);

	/**

		* Use to retrieve the rule variant index based on Id.

		* @since 2.8

			* @param aRuleVariantID Identifier of rule variant.

		* @return Rule variant.

        */

		IMPORT_C virtual TInt Find(TSIRuleVariantID aRuleVariantID) const;

		IMPORT_C virtual CSIRuleVariant&  RuleVariantL(TSIRuleVariantID aRuleVariantID) const;

		/**

		* Use to delete rule variant.

		* @since 2.8

		* @param aRuleVariant Rule variant identifier.

			* @return None.

        */

		IMPORT_C virtual void DeleteL(TSIRuleVariantID aRuleVariantID);

        /**

        * Compares two CSIRule objects.

        * Returns 0 if rule ids are equal.

        * Returns -1 if first id is smaller.

        * Returns 1 if second id is smaller.

        *

        * @param "const CSIRule& aFirst" First rule to compare

        * @param "const CSIRule& aSecond" Second rule to compare

        * @return 0, -1 or 1

        */

		static TInt Compare( const CSIRule& aFirst, const CSIRule& aSecond );

	protected:

		IMPORT_C virtual void ConstructL();

		IMPORT_C CSIRule( const TSIRuleID aRuleID );

	private:

		TSIRuleID iRuleID;

		RPointerArray<CSIRuleVariant> iRuleVariantArray;

		TAny* iReserved;

	};

/**

*  Class to encapsulate a Speaker Independent Grammar

*  A grammar consist of a list of rules

*

*  @lib nsssispeechrecognitiondata.lib

*  @since 2.8

*/

class CSIGrammar : public CBase

	{

	public:// Constructors and destructor

		   /**

		   * Destructor.

        */

		IMPORT_C virtual ~CSIGrammar();

        /**

        * Two-phased constructor.

        */

		IMPORT_C static CSIGrammar* NewL(const TSIGrammarID aGrammarID);

		IMPORT_C static CSIGrammar* NewLC(const TSIGrammarID aGrammarID);

	public: // New functions

		/**

        * Use to add a rule to the grammar.

        * @since 2.8

		* @param aRule - reference to CSIRule object.

        * @return KErrNone, if the insertion is successful, otherwise one of the system wide error codes.

        */

		IMPORT_C virtual void AddL(CSIRule* aRule);

		/**

        * Use to return a rule based at an index.

        * @since 2.8

		* @param aIndex: an index. Value must not be negative and must not be greater than the number of rules currently in the grammar, otherwise it raises a USER-130 panic.

        * @return Reference to CSIRule object.

        */

		IMPORT_C virtual CSIRule& AtL(TInt aIndex) const;

		/**

        * Use to delete a rule to the grammar.

        * @since 2.8

		* @param aRuleID - rule identifier.

        * @return None.

        */

		IMPORT_C virtual void DeleteL(const TSIRuleID aRuleID);

		/**

        * Use to get the number of rules in the grammar

        * @since 2.8

		* @param None.

        * @return Number of rules.

        */  

		IMPORT_C virtual TInt Count() const;

		/**

			* Use to retrieve the grammar Id of the result.

			* @since 2.8

			* @param None.

			* @return Grammar identifier.

        */

		IMPORT_C virtual TSIGrammarID GrammarID() const;

		/**

        * Use to find a rule in the grammar based on rule Id.

        * @since 2.8

		* @param aRuleID - rule identifier.

        * @return The index of the first matching rule within the grammar.  KErrNotFound, if no matching rule can be found.

        */ 

		IMPORT_C virtual TInt Find(const TSIRuleID aRuleID) const;

		IMPORT_C virtual CSIRule&  RuleL(TSIRuleID aRuleID) const;

		/**

        * Internalize to a data stream

        * @since 2.8

		* @param aStream Data stream

        * @return  None

        */ 

		IMPORT_C virtual void InternalizeL(RReadStream& aStream );

		/**

        * Externalize from a data stream

        * @since 2.8

		* @param None

        * @return  aStream Data stream

        */ 

		IMPORT_C virtual void ExternalizeL(RWriteStream& aStream ) const;

 	protected:

		IMPORT_C virtual void ConstructL();

		IMPORT_C CSIGrammar(const TSIGrammarID aGrammarID);

	private:

		TSIGrammarID iGrammarID;

		RPointerArray<CSIRule> iRuleArray;

		TAny* iReserved;

	};

/**

*  Class to encapsulate a compiled grammar (ready for recognition)

*

*  @lib nsssispeechrecognitiondata.lib

*  @since 2.8

*/ 

class CSICompiledGrammar : public CSIGrammar

	{

	public:// Constructors and destructor

		   /**

		   * Destructor.

        */

		IMPORT_C virtual ~CSICompiledGrammar();

        /**

        * Two-phased constructor.

        */

		IMPORT_C static CSICompiledGrammar* NewL(const TSIGrammarID aGrammarID); 

		IMPORT_C static CSICompiledGrammar* NewLC(const TSIGrammarID aGrammarID); 

	public: // New functions

				/**

        * Use to delete a rule to the grammar.

        * @since 2.8

		* @param aRuleID - rule identifier.

        * @return None.

        */

		IMPORT_C virtual void DeleteL(const TSIRuleID aRuleID);

		/**

        * Use to add a rule to the grammar.

        * @since 2.8

		* @param aRule - reference to CSIRule object.

        * @return KErrNone, if the insertion is successful, otherwise one of the system wide error codes.

        */

		IMPORT_C virtual void AddL(CSIRule* aRule);

		/**

        * Use to retrieve the recognition data.

        * @since 2.8

		* @param None.

        * @return Reference to the recognition data.

        */ 

 		IMPORT_C virtual void SetCompiledData( HBufC8* aCompilerData);

		/**

        * Function to get compiler data

        * @since 2.8

        * @param None

        * @return Pointer to data

        */	

		IMPORT_C virtual TDesC8&  CompiledData() const;

		/**

        * Internalize to a data stream

        * @since 2.8

		* @param aStream Data stream

        * @return  None

        */ 

		IMPORT_C virtual void InternalizeL(RReadStream& aStream );

		/**

        * Externalize from a data stream

        * @since 2.8

		* @param None

        * @return  aStream Data stream

        */ 

		IMPORT_C virtual void ExternalizeL(RWriteStream& aStream ) const;

	protected:

		IMPORT_C virtual void ConstructL();

		IMPORT_C CSICompiledGrammar(const TSIGrammarID aGrammarID);

	private:

		// is compiled data valid

		TBool iValidData;

		// data of grammar compiler

		HBufC8*  iGrammarCompilerData;

		TAny* iReserved;

	protected:

	};

/**

*  Class to define rule variant info

*

*  @lib nsssispeechrecognitiondata.lib

*  @since 2.8

*/

class TSIRuleVariantInfo

	{

	public:  // Constructors and destructor

        /**

        * C++ default constructor.

        */

        IMPORT_C TSIRuleVariantInfo( const TSIGrammarID aGrammarID, 

                                     const TSIRuleID aRuleID, 

                                     const TSIRuleVariantID aRuleVariantID );

        /**

        * Destructor.

        */

        IMPORT_C virtual ~TSIRuleVariantInfo();

	public: // New functions

			/**

			* Use to get Grammar ID

			* @since 2.8

			* @return Identifier of Grammar

		*/

		IMPORT_C virtual TSIGrammarID GrammarID() const;

			/**

			* Use to get rule ID

			* @since 2.8

			* @return Identifier of rule

		*/

		IMPORT_C virtual TSIRuleID RuleID() const;

		/**

		* Use to get rule variant ID

		* @since 2.8

		* @return Identifier of rule variant

		*/

		IMPORT_C virtual TSIRuleVariantID RuleVariantID() const;

	protected:    // Data