/*

* Copyright (c) 2004-2007 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.

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <s32mem.h>

#include "nsssispeechrecognitiondatadevasr.h"

#include "nsssispeechrecognitiondatatest.h"

#include "nsssidataserialize.h"

#include "rubydebug.h"

// CONSTANTS

/** Maximal number of pronunciations, that is allowed to be stored per lexicon.

    0 means no limit.

    4800 is a maximal number of pronunciations for 400 contacts (400*12) */

const TInt KMaxPronunciations = 4800;

// Starting value for lexicon usage counter

const TInt KInitialCounterValue = 1;

// Define this if SINDE lexicon optimization is on

#define __SIND_LEXICON_OPT

/*****************************************************************************/

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CSIParameters::CSIParameters

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

EXPORT_C CSIParameters::CSIParameters()

{

}

// -----------------------------------------------------------------------------

// CSIParameters::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

EXPORT_C void CSIParameters::ConstructL()

{

} 

// -----------------------------------------------------------------------------

// CSIParameters::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

EXPORT_C CSIParameters* CSIParameters::NewL()

{

	CSIParameters* self = NewLC();

  	CleanupStack::Pop( self );

    return self;

}

// -----------------------------------------------------------------------------

// CSIParameters::NewLC

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

EXPORT_C CSIParameters* CSIParameters::NewLC()

{

	CSIParameters* self = new (ELeave) CSIParameters();

    CleanupStack::PushL( self );

    self->ConstructL(); 

    return self;

}

// -----------------------------------------------------------------------------

// CSIParameters::~CSIParameters

// Destructor.

// -----------------------------------------------------------------------------

//

EXPORT_C CSIParameters::~CSIParameters()

{

	iParameterValues.Reset();

	iParameterIDs.Reset();

}

// -----------------------------------------------------------------------------

// CSIParameters::SetParameterL

// Sets a value X to parameter Y.

// (other items were commented in the headers)

// -----------------------------------------------------------------------------

//

EXPORT_C void CSIParameters::SetParameterL( const TInt aParameterID, const TInt aParameterValue )

{

	RUBY_DEBUG_BLOCKL("CSIParameters::SetParameterL");

    TInt index = iParameterIDs.Find( aParameterID );

    // If the parameter has been set earlier, update the value

    if ( index != KErrNotFound )

        {

        iParameterValues[index] = aParameterValue;

        }

    else{

		// create new item for ID and value

		User::LeaveIfError( iParameterIDs.Append( aParameterID ) );

		TInt error = iParameterValues.Append( aParameterValue );

		if ( error )

		    {

			// remove the previously added

			iParameterIDs.Remove( iParameterIDs.Count() - 1 );

			User::Leave( error );

		    }

        }

}

// -----------------------------------------------------------------------------

// CSIParameters::ParameterL

// Returns the value of a parameter.

// (other items were commented in the headers)

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CSIParameters::ParameterL( const TInt aParameterID ) const

{

	RUBY_DEBUG_BLOCK("CSIParameters::ParameterL");

    TInt index = iParameterIDs.Find( aParameterID );

    // Leave, if not found.

    User::LeaveIfError( index );

    return iParameterValues[index];

}

// -----------------------------------------------------------------------------

// CSIParameters::InternalizeL

// Restores the object from the stream.

// (other items were commented in the headers)

// -----------------------------------------------------------------------------

//

EXPORT_C void CSIParameters::InternalizeL( RReadStream& aStream )

    {

    RUBY_DEBUG_BLOCKL("CSIParameters::InternalizeL");

    if ( iParameterIDs.Count() > 0 )

        {

        User::Leave( KErrInUse );

        }

    // Check ID 

    if ( aStream.ReadInt32L() != KBinaryParameterID )

        User::Leave( KErrCorrupt );

    // Param count; can be 0.

    TInt count = aStream.ReadInt32L();

    // Read values

    for( TInt k( 0 ); k < count; k++ )

        {

        TInt id    = aStream.ReadInt32L();

        TInt value = aStream.ReadInt32L();

        SetParameterL( id, value );

        }

    }

// -----------------------------------------------------------------------------

// CSIParameters::ExternalizeL

// Stores the object to a stream.

// (other items were commented in the headers)

// -----------------------------------------------------------------------------

//

EXPORT_C void CSIParameters::ExternalizeL(RWriteStream& aStream ) const

    {

    TInt count = iParameterIDs.Count();

    // Write ID 

    aStream.WriteInt32L( KBinaryParameterID );

    // Param count; can be 0.

    aStream.WriteInt32L( count );

    for( TInt k( 0 ); k < count; k++ )

        {

        aStream.WriteInt32L( iParameterIDs   [k] );

        aStream.WriteInt32L( iParameterValues[k] );

        }

    }

// -----------------------------------------------------------------------------

// CSIParameters::ListParametersL

// Populates given arrays with parameter IDs and values.

// (other items were commented in the headers)

// -----------------------------------------------------------------------------

//

EXPORT_C void CSIParameters::ListParametersL( RArray<TInt>& aParameterIDs, 

                                              RArray<TInt>& aParameterValues ) const

    {

    RUBY_DEBUG_BLOCKL("CSIParameters::ListParametersL");

    TInt i = 0;

    aParameterIDs.Reset();

    aParameterValues.Reset();

    // Loop through all parameter IDs

    for ( i = 0; i < iParameterIDs.Count(); i++ )

        {

        aParameterIDs.Append( iParameterIDs[i] );

        }

    // Loop through all parameter values

    for ( i = 0; i < iParameterValues.Count(); i++ )

        {

        aParameterValues.Append( iParameterValues[i] );

        }

    }

/*****************************************************************************/

// -----------------------------------------------------------------------------

// CSIRuleVariant::CSIRuleVariant

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

EXPORT_C CSIRuleVariant::CSIRuleVariant( const TSIRuleVariantID aRuleVariantID, 

										const TSILexiconID aLexiconID)

										:	iRuleVariantID(aRuleVariantID),

										iLexiconID(aLexiconID),

										iLanguage( ELangEnglish) // UK English as default

{

}

// -----------------------------------------------------------------------------

// CSIRuleVariant::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

EXPORT_C void CSIRuleVariant::ConstructL()

{

	CSIParameters::ConstructL();

} 

// -----------------------------------------------------------------------------

// CSIRuleVariant::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

EXPORT_C CSIRuleVariant* CSIRuleVariant::NewL(const TSIRuleVariantID aRuleVariantID, 

											  const TSILexiconID aLexiconID)

{

	CSIRuleVariant* self =  NewLC(aRuleVariantID, aLexiconID );

    CleanupStack::Pop( self );

    return self;

}

// -----------------------------------------------------------------------------

// CSIRuleVariant::NewLC

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

EXPORT_C CSIRuleVariant* CSIRuleVariant::NewLC(const TSIRuleVariantID aRuleVariantID, 

											  const TSILexiconID aLexiconID)

{

	CSIRuleVariant* self = new (ELeave) CSIRuleVariant(aRuleVariantID, aLexiconID );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

}

// -----------------------------------------------------------------------------

// CSIRuleVariant::~CSIParameters

// Destructor.

// -----------------------------------------------------------------------------

//

EXPORT_C CSIRuleVariant::~CSIRuleVariant()

{

	iPronunciationIDs.Reset();

}

// -----------------------------------------------------------------------------

// CSIRuleVariant::RuleVariantID

// Returns the ID of the rule variant.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

EXPORT_C TSIRuleVariantID CSIRuleVariant::RuleVariantID() const

{

	return iRuleVariantID;

}

// -----------------------------------------------------------------------------

// CSIRuleVariant::LexiconID

// Returns the ID of the lexicon, which contains the pronunciations.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

EXPORT_C TSILexiconID CSIRuleVariant::LexiconID() const

{

	return iLexiconID;

}

// -----------------------------------------------------------------------------

// CSIRuleVariant::SetPronunciationIDsL

// Sets the pronunciation.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

EXPORT_C void CSIRuleVariant::SetPronunciationIDsL( const TSIPronunciationIDSequence& aPronunciationIDs)

{

	RUBY_DEBUG_BLOCKL("CSIRuleVariant::SetPronunciationIDsL");

	for ( TInt i( 0 ); i < aPronunciationIDs.Count(); i++)

	{

		User::LeaveIfError( iPronunciationIDs.Append( aPronunciationIDs[i] ) );

	}

}

// -----------------------------------------------------------------------------

// CSIRuleVariant::GetPronunciationIDsL

// Fetches the pronunciation.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

EXPORT_C void CSIRuleVariant::GetPronunciationIDsL( TSIPronunciationIDSequence& aPronunciationIDs ) const

{

	RUBY_DEBUG_BLOCKL("CSIRuleVariant::GetPronunciationIDsL");

	aPronunciationIDs.Reset();

	for ( TInt i( 0 ); i < iPronunciationIDs.Count(); i++)

	{

		User::LeaveIfError( aPronunciationIDs.Append( iPronunciationIDs[i] ) );

	}

}

// -----------------------------------------------------------------------------

// CSIRuleVariant::SetLanguage

// Sets the pronunciation language.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

EXPORT_C void CSIRuleVariant::SetLanguage(TLanguage aLanguage)

{

	iLanguage=aLanguage;

}

// -----------------------------------------------------------------------------

// CSIRuleVariant::Language

// Gets the pronunciation language.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

EXPORT_C TLanguage CSIRuleVariant::Language() const

{

	return iLanguage;

}

/*****************************************************************************/

// -----------------------------------------------------------------------------

// CSIRule::CSIRule

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

EXPORT_C CSIRule::CSIRule(TSIRuleID aRuleID)

:	iRuleID(aRuleID)

{

}

// -----------------------------------------------------------------------------

// CSIRule::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

EXPORT_C void CSIRule::ConstructL()

{

}

// -----------------------------------------------------------------------------

// CSIRule::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

EXPORT_C CSIRule* CSIRule::NewL(const TSIRuleID aRuleID)

{

	CSIRule* self = NewLC(aRuleID); 

	CleanupStack::Pop(self);

    return self;

}

// -----------------------------------------------------------------------------

// CSIRule::NewLC

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

EXPORT_C CSIRule* CSIRule::NewLC(const TSIRuleID aRuleID)

{

	CSIRule* self = new (ELeave) CSIRule(aRuleID);

    CleanupStack::PushL( self );

    self->ConstructL();

	return self;

}

// -----------------------------------------------------------------------------

// CSIRule::~CSIRule

// Destructor.

// -----------------------------------------------------------------------------

//

EXPORT_C CSIRule::~CSIRule()

{

	iRuleVariantArray.ResetAndDestroy();

}

// -----------------------------------------------------------------------------

// CSIRule::RuleID

// Returns the ID of the rule.

// -----------------------------------------------------------------------------

//

EXPORT_C TSIRuleID CSIRule::RuleID() const

{

	return iRuleID;

} 

// -----------------------------------------------------------------------------

// CSIRule::Count

// Returns the number of rule variants.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CSIRule::Count() const

{

	return iRuleVariantArray.Count();

}

// -----------------------------------------------------------------------------

// CSIRule::Compare

// Compares two CSIRule objects to each other based on ids.

// -----------------------------------------------------------------------------

//

TInt CSIRule::Compare( const CSIRule& aFirst, 

                       const CSIRule& aSecond )

    {

    if ( aFirst.RuleID() < aSecond.RuleID() )

        {

        return -1;

        }

    if ( aFirst.RuleID() > aSecond.RuleID() )

        {

        return 1;

        }

    // IDs are equal

    return 0;

    }

// -----------------------------------------------------------------------------

// CSIRule::AtL

// Used to get a variant.

// -----------------------------------------------------------------------------

//

EXPORT_C CSIRuleVariant& CSIRule::AtL(TInt aIndex) const

{

	// too much output RUBY_DEBUG_BLOCK("CSIRule::AtL"); 

	if(aIndex<0 || aIndex >= Count()) 

		{

		RUBY_DEBUG2("[Error!]CSIRule::AtL index [%d] is out of bounds. Count is [%d]. Leaving with KErrArgument", aIndex, Count());

		User::Leave(KErrArgument);

		}		

	return *(iRuleVariantArray[aIndex]);

}

// -----------------------------------------------------------------------------

// CSIRule::Find

// Returns the index of the variant with given id.

// -----------------------------------------------------------------------------

//

EXPORT_C  TInt CSIRule::Find(TSIRuleVariantID aRuleVariantID) const

{

	for ( TInt i(0); i < iRuleVariantArray.Count(); i++ )

	{

		if ( aRuleVariantID == iRuleVariantArray[i]->RuleVariantID() )

		{

			return i;

		}

	} 

	return( KErrNotFound );

}

// -----------------------------------------------------------------------------

// CSIRule::AddL

// Adds a rule variant to the rule.

// -----------------------------------------------------------------------------

//

EXPORT_C void CSIRule::AddL( CSIRuleVariant* aRuleVariant )

{

	RUBY_DEBUG_BLOCKL("CSIRule::AddL");

    // Check that the rule isn't already there

	if ( Find( aRuleVariant->RuleVariantID() ) != KErrNotFound )

	{

		User::Leave( KErrAlreadyExists );

	}

    User::LeaveIfError( iRuleVariantArray.Append( aRuleVariant ) );

}

// -----------------------------------------------------------------------------

// CSIRule::RuleVariantL

// Used to get a rule variant with given ID.

// -----------------------------------------------------------------------------

//

EXPORT_C  CSIRuleVariant& CSIRule::RuleVariantL(TSIRuleVariantID aRuleVariantID) const

{

	RUBY_DEBUG_BLOCK("CSIRule::RuleVariantL");

	TInt aIndex = Find(aRuleVariantID);