diff -r cad71a31b7fc -r e36f3802f733 srsf/sispeechrecognitiondata/src/nsssispeechrecognitiondatadevasr.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/srsf/sispeechrecognitiondata/src/nsssispeechrecognitiondatadevasr.cpp Wed Sep 01 12:29:17 2010 +0100 @@ -0,0 +1,2575 @@ +/* +* 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 +#include +#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& aParameterIDs, + RArray& 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); + + User::LeaveIfError( aIndex ); + + return(AtL(aIndex)); +} + +// ----------------------------------------------------------------------------- +// CSIRule::DeleteL +// Deletes the rule variant with given ID. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIRule::DeleteL(TSIRuleVariantID aRuleVariantID) +{ + RUBY_DEBUG_BLOCK("CSIRule::DeleteL"); + TInt index = User::LeaveIfError( Find( aRuleVariantID ) ); + + delete iRuleVariantArray[index]; + iRuleVariantArray.Remove(index); +} + + + + + +/*****************************************************************************/ + +// ----------------------------------------------------------------------------- +// CSIGrammar::CSIGrammar +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIGrammar::CSIGrammar(TSIGrammarID aGrammarID) +: iGrammarID(aGrammarID) +{ +} + +// ----------------------------------------------------------------------------- +// CSIGrammar::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIGrammar::ConstructL() +{ +} + +// ----------------------------------------------------------------------------- +// CSIGrammar::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIGrammar* CSIGrammar::NewL(const TSIGrammarID aGrammarID) +{ + CSIGrammar* self = NewLC(aGrammarID); + CleanupStack::Pop(self); + return self; +} + +// ----------------------------------------------------------------------------- +// CSIGrammar::NewLC +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIGrammar* CSIGrammar::NewLC(const TSIGrammarID aGrammarID) +{ + CSIGrammar* self = new (ELeave) CSIGrammar(aGrammarID); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + +} + +// ----------------------------------------------------------------------------- +// CSIGrammar::~CSIGrammar +// Destructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIGrammar::~CSIGrammar() +{ + iRuleArray.ResetAndDestroy(); + iRuleArray.Close(); +} + + + +// ----------------------------------------------------------------------------- +// CSIGrammar::GrammarID +// Returns the ID of the given grammar. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C TSIGrammarID CSIGrammar::GrammarID() const +{ + return iGrammarID; +} + + +// ----------------------------------------------------------------------------- +// CSIGrammar::AddL +// Adds a rule to the grammar. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIGrammar::AddL(CSIRule* aRule) +{ + // too much output RUBY_DEBUG_BLOCKL("CSIGrammar::AddL"); + + // Order function which is used when finding the correct place to insert + TLinearOrder order( CSIRule::Compare ); + + // InsertInOrderL does not allow duplicates + iRuleArray.InsertInOrderL( aRule, order ); +} + +// ----------------------------------------------------------------------------- +// CSIGrammar::DeleteL +// Deletes a rule with given ID. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIGrammar::DeleteL(TSIRuleID aRuleID) +{ + RUBY_DEBUG_BLOCK("CSIGrammar::DeleteL"); + TInt index = Find(aRuleID); + User::LeaveIfError( index ); + + delete iRuleArray[index]; + iRuleArray.Remove(index); +} + +// ----------------------------------------------------------------------------- +// CSIGrammar::AtL +// Used to get a rule. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIRule& CSIGrammar::AtL(TInt anIndex) const +{ + if(anIndex<0 || anIndex >= Count()) + { + RUBY_DEBUG2("[Error!]CSIGrammar::AtL index [%d] is out of bounds. Count is [%d]. Leaving with KErrArgument", anIndex, Count()); + User::Leave(KErrArgument); + } + + return *(iRuleArray[anIndex]); + +} + +// ----------------------------------------------------------------------------- +// CSIGrammar::Find +// Finds the index of the rule with given ID. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CSIGrammar::Find(TSIRuleID aRuleID) const +{ + // Order function which is used when finding the correct item + TLinearOrder order( CSIRule::Compare ); + + TInt retVal = KErrNotFound; + + TRAPD( error, + + // Construct a 'dummy' CSIPronunciation so that comparison can be done + // against it + CSIRule* rule = CSIRule::NewL( aRuleID ); + + CleanupStack::PushL( rule ); + + // Use binary search since array is kept in the order of rule ids + retVal = iRuleArray.FindInOrderL( rule, order ); + + CleanupStack::PopAndDestroy( rule ); + ); + + if ( error != KErrNone ) + { + return error; + } + return retVal; +} + +// ----------------------------------------------------------------------------- +// CSIGrammar::Count +// Returns the number of rules. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CSIGrammar::Count() const +{ + return iRuleArray.Count(); +} + +// ----------------------------------------------------------------------------- +// CSIGrammar::RuleL +// Used to get a rule with given ID. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIRule& CSIGrammar::RuleL(TSIRuleID aRuleID) const +{ + RUBY_DEBUG_BLOCK("CSIGrammar::RuleL"); + TInt aIndex = Find(aRuleID); +#ifdef _DEBUG + if( aIndex < 0 ) + { + RUBY_DEBUG2("CSIGrammar::RuleL Error [%d] finding aRuleID [%d]. Leaving", aIndex, aRuleID); + } +#endif + User::LeaveIfError( aIndex ); + + return(AtL(aIndex)); +} + +// ----------------------------------------------------------------------------- +// CSIGrammar::ExternalizeL +// Stores the object to the stream. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIGrammar::ExternalizeL( RWriteStream& aWriteStream ) const + { + aWriteStream.WriteInt32L( KBinaryGrammarID ); + + CSIGrammarSerializer* grammarSerializer = CSIGrammarSerializer::NewLC( *this ); + grammarSerializer->ExternalizeL( aWriteStream ); + CleanupStack::PopAndDestroy( grammarSerializer ); + + aWriteStream.WriteInt32L( KBinaryGrammarID ); + } + +// ----------------------------------------------------------------------------- +// CSIGrammar::InternalizeL +// Restores the object from a stream. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIGrammar::InternalizeL( RReadStream& aReadStream ) + { + RUBY_DEBUG_BLOCK("CSIGrammar::InternalizeL"); + if ( iRuleArray.Count() > 0 ) + { + User::Leave( KErrInUse ); + } + + // Read header: Format ID, grammar ID and number of rules. + if ( aReadStream.ReadInt32L() != KBinaryGrammarID ) + { + User::Leave( KErrCorrupt ); + } + + CSIGrammarSerializer* grammarSerializer + = CSIGrammarSerializer::NewLC( aReadStream ); + + grammarSerializer->RestoreL( *this, iGrammarID ); + CleanupStack::PopAndDestroy( grammarSerializer ); + + if ( aReadStream.ReadInt32L() != KBinaryGrammarID ) + { + User::Leave( KErrCorrupt ); + } + } + +/*****************************************************************************/ + +// ----------------------------------------------------------------------------- +// CSICompiledGrammar::CSICompiledGrammar +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSICompiledGrammar::CSICompiledGrammar(TSIGrammarID aGrammarID + ) + : CSIGrammar(aGrammarID), iValidData(EFalse), iGrammarCompilerData( NULL ) +{ +} + +// ----------------------------------------------------------------------------- +// CSICompiledGrammar::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSICompiledGrammar::ConstructL() +{ +} + +// ----------------------------------------------------------------------------- +// CSICompiledGrammar::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSICompiledGrammar* CSICompiledGrammar::NewL(TSIGrammarID aGrammarID) +{ + CSICompiledGrammar* self = NewLC(aGrammarID) ; + CleanupStack::Pop(self); + return self; +} + +// ----------------------------------------------------------------------------- +// CSICompiledGrammar::NewLC +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSICompiledGrammar* CSICompiledGrammar::NewLC(TSIGrammarID aGrammarID) +{ + CSICompiledGrammar* self = new (ELeave) CSICompiledGrammar(aGrammarID) ; + CleanupStack::PushL( self ); + self->ConstructL(); + return self; +} + +// ----------------------------------------------------------------------------- +// CSICompiledGrammar::~CSICompiledGrammar +// Destructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSICompiledGrammar::~CSICompiledGrammar() +{ + delete iGrammarCompilerData; +} + +// ----------------------------------------------------------------------------- +// CSICompiledGrammar::AddL +// Adds a new rule to the grammar. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSICompiledGrammar::AddL(CSIRule* aRule) +{ + RUBY_DEBUG_BLOCKL("CSICompiledGrammar::AddL"); + iValidData = EFalse; + CSIGrammar::AddL(aRule); +} + +// ----------------------------------------------------------------------------- +// CSICompiledGrammar::DeleteL +// Delets a rule with given ID. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSICompiledGrammar::DeleteL(TSIRuleID aRuleID) +{ + RUBY_DEBUG_BLOCK("CSICompiledGrammar::DeleteL"); + iValidData = EFalse; + CSIGrammar::DeleteL(aRuleID); +} + + +// ----------------------------------------------------------------------------- +// CSICompiledGrammar::SetCompiledData +// Sets the compiled grammar data. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSICompiledGrammar::SetCompiledData( HBufC8* aCompilerData ) +{ + delete iGrammarCompilerData; + iGrammarCompilerData = aCompilerData; +} + + +// ----------------------------------------------------------------------------- +// CSICompiledGrammar::CompiledData +// Gets a descriptor to the compiled grammar data. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C TDesC8& CSICompiledGrammar::CompiledData() const +{ + return *iGrammarCompilerData; +} + +// ----------------------------------------------------------------------------- +// CSICompiledGrammar::ExternalizeL +// Stores the object to the stream. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSICompiledGrammar::ExternalizeL( RWriteStream& aWriteStream ) const + { + aWriteStream.WriteInt32L( KBinaryCompiledGrammarID ); + + CSIGrammar::ExternalizeL( aWriteStream ); + + // Read compiled grammar data + if ( iGrammarCompilerData ) + { + TInt length = iGrammarCompilerData->Length(); + aWriteStream.WriteInt32L( length ); + aWriteStream.WriteL( iGrammarCompilerData->Des(), length ); + } + else + { + aWriteStream.WriteInt32L( 0 ); + } + + // Corruption check + aWriteStream.WriteInt32L( KBinaryCompiledGrammarID ); + } + +// ----------------------------------------------------------------------------- +// CSICompiledGrammar::InternalizeL +// Restores the object from a stream. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSICompiledGrammar::InternalizeL( RReadStream& aReadStream ) + { + RUBY_DEBUG_BLOCK("CSICompiledGrammar::InternalizeL"); + if ( aReadStream.ReadInt32L() != KBinaryCompiledGrammarID ) + User::Leave( KErrCorrupt ); + + CSIGrammar::InternalizeL( aReadStream ); + + // Read compiled grammar data + TInt length = aReadStream.ReadInt32L(); + + if ( length > 0 ) + { + iGrammarCompilerData = HBufC8::NewL( length ); + TPtr8 compilerDataPtr = iGrammarCompilerData->Des(); + aReadStream.ReadL( compilerDataPtr, length ); + } + + // Corruption check + if ( aReadStream.ReadInt32L() != KBinaryCompiledGrammarID ) + User::Leave( KErrCorrupt ); + } + +/*****************************************************************************/ +// ----------------------------------------------------------------------------- +// TSIRuleVariantInfo::TSIRuleVariantInfo +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +EXPORT_C TSIRuleVariantInfo::TSIRuleVariantInfo( + const TSIGrammarID aGrammarID, + const TSIRuleID aRuleID, + const TSIRuleVariantID aRuleVariantID ) + : iGrammarID( aGrammarID ), + iRuleID( aRuleID ), + iRuleVariantID( aRuleVariantID ) +{ + // nothing +} + +// ----------------------------------------------------------------------------- +// TSIRuleVariantInfo::~TSIRuleVariantInfo +// Destructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C TSIRuleVariantInfo::~TSIRuleVariantInfo() +{ + // nothing +} + + +// ----------------------------------------------------------------------------- +// TSIRuleVariantInfo::GrammarID +// Returns the grammar ID. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C TSIGrammarID TSIRuleVariantInfo::GrammarID() const +{ + return iGrammarID; +} +// ----------------------------------------------------------------------------- +// TSIRuleVariantInfo::RuleID +// Return rule identifier. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C TSIRuleID TSIRuleVariantInfo::RuleID() const +{ + return iRuleID; +} + +// ----------------------------------------------------------------------------- +// TSIRuleVariantInfo::RuleVariantID +// Return rule variant identifier. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C TSIRuleVariantID TSIRuleVariantInfo::RuleVariantID() const +{ + return iRuleVariantID; +} + +/******************************************************************************/ + +// ----------------------------------------------------------------------------- +// CSIPronunciation::CSIPronunciation +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIPronunciation::CSIPronunciation( const TSIPronunciationID aPronunciationID, + const TSIModelBankID aModelBankID ) + : iPronunciationID( aPronunciationID ), + iModelBankID( aModelBankID ), + iPhonemeSequence( NULL ) + { + } + +// ----------------------------------------------------------------------------- +// CSIPronunciation::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIPronunciation::ConstructL() + { + } + + +// ----------------------------------------------------------------------------- +// CSIPronunciation::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIPronunciation* CSIPronunciation::NewL( const TSIPronunciationID aPronunciationID, + const TSIModelBankID aModelBankID ) + { + CSIPronunciation* self = NewLC ( aPronunciationID, aModelBankID ); + CleanupStack::Pop( self ); + return self; + } + + + +// ----------------------------------------------------------------------------- +// CSIPronunciation::NewLC +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIPronunciation* CSIPronunciation::NewLC( const TSIPronunciationID aPronunciationID, + const TSIModelBankID aModelBankID ) + { + CSIPronunciation* self = new (ELeave) CSIPronunciation( aPronunciationID, aModelBankID ); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +// ----------------------------------------------------------------------------- +// CSIPronunciation::~CSIPronunciation +// Destructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIPronunciation::~CSIPronunciation() + { + delete iPhonemeSequence; + } + +// ----------------------------------------------------------------------------- +// CSIPronunciation::Compare +// Compares two CSIPronunciation objects to each other based on ids. +// ----------------------------------------------------------------------------- +// +TInt CSIPronunciation::Compare( const CSIPronunciation& aFirst, + const CSIPronunciation& aSecond ) + { + if ( aFirst.PronunciationID() < aSecond.PronunciationID() ) + { + return -1; + } + if ( aFirst.PronunciationID() > aSecond.PronunciationID() ) + { + return 1; + } + // IDs are equal + return 0; + } + +// ----------------------------------------------------------------------------- +// CSIPronunciation::ComparePhonemes +// Compares two CSIPronunciation objects to each other based pronunciations. +// ----------------------------------------------------------------------------- +// +TInt CSIPronunciation::ComparePhonemes( const CSIPronunciation& aFirst, + const CSIPronunciation& aSecond ) + { + if ( aFirst.PhonemeSequence() < aSecond.PhonemeSequence() ) + { + return -1; + } + if ( aFirst.PhonemeSequence() > aSecond.PhonemeSequence() ) + { + return 1; + } + // Phoneme sequences are equal + return 0; + } + +// ----------------------------------------------------------------------------- +// CSIPronunciation::PronunciationID +// Returns the pronunciation ID. +// ----------------------------------------------------------------------------- +// +EXPORT_C TSIPronunciationID CSIPronunciation::PronunciationID() const + { + return iPronunciationID; + } + +// ----------------------------------------------------------------------------- +// CSIPronunciation::ModelBankID +// Returns the pronunciation ID. +// ----------------------------------------------------------------------------- +// +EXPORT_C TSIModelBankID CSIPronunciation::ModelBankID() const + { + return iModelBankID; + } + +// ----------------------------------------------------------------------------- +// CSIPronunciation::SetPhonemeSequenceL +// Sets Phoneme Sequence +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIPronunciation::SetPhonemeSequenceL( const TDesC8& aPhonemeSequence ) + { + if ( iPhonemeSequence ) + { + // delete old data + delete iPhonemeSequence; + iPhonemeSequence = NULL; + } + + iPhonemeSequence = HBufC8::NewL( aPhonemeSequence.Length() ); + (*iPhonemeSequence) = aPhonemeSequence; + } + + +// ----------------------------------------------------------------------------- +// CSIPronunciation::PhonemeSequence +// returns Phoneme Sequence +// ----------------------------------------------------------------------------- +// +EXPORT_C const TDesC8& CSIPronunciation::PhonemeSequence() const + { + return *iPhonemeSequence; + } + +// ----------------------------------------------------------------------------- +// CSIPronunciation::SetPronunciationID +// Sets the pronunciation ID. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIPronunciation::SetPronunciationID( TSIPronunciationID aPronunciationID ) + { + iPronunciationID=aPronunciationID; + } + +/*****************************************************************************/ + +// ----------------------------------------------------------------------------- +// CSILexicon::CSILexicon +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSILexicon::CSILexicon( TSILexiconID aLexiconID ) + : iLexiconID(aLexiconID) + { + } + +// ----------------------------------------------------------------------------- +// CSILexicon::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSILexicon::ConstructL() + { + } + +// ----------------------------------------------------------------------------- +// CSILexicon::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSILexicon* CSILexicon::NewL( TSILexiconID aLexiconID ) + { + CSILexicon* self = NewLC( aLexiconID ); + CleanupStack::Pop( self ); + return self; + } + + +// ----------------------------------------------------------------------------- +// CSILexicon::NewLC +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSILexicon* CSILexicon::NewLC( TSILexiconID aLexiconID ) + { + CSILexicon* self = new ( ELeave ) CSILexicon( aLexiconID ); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +// ----------------------------------------------------------------------------- +// CSILexicon::~CSILexicon +// Destructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSILexicon::~CSILexicon() + { + iPronunciationArray.ResetAndDestroy(); + iPronunciationArray.Close(); + iPronunOrder.Close(); + } + +// ----------------------------------------------------------------------------- +// CSILexicon::LexiconID +// Gets the ID of the lexicon. +// ----------------------------------------------------------------------------- +// +EXPORT_C TSIGrammarID CSILexicon::LexiconID() const + { + return iLexiconID; + } + +// ----------------------------------------------------------------------------- +// CSILexicon::AddL +// Adds a pronunciation. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSILexicon::AddL( CSIPronunciation* aPronunciation ) + { +#ifdef __SIND_LEXICON_OPT + RUBY_DEBUG_BLOCKL( "CSILexicon::AddL (SINDE optimized)" ); + + RUBY_ASSERT_DEBUG( iPronunciationArray.Count() == iPronunOrder.Count(), User::Leave( KErrCorrupt ) ); + + // Check if current lexicon already holds maximal allowed number of + // pronunciations or that there is no limit + if( ( KMaxPronunciations != 0 ) && ( iPronunciationArray.Count() > KMaxPronunciations ) ) + { + User::Leave( KErrNoMemory ); + } + + if ( aPronunciation == NULL ) + { + User::Leave( KErrArgument ); + } + + // Check that pronunciation is not null + const TDesC8& phonemeSeq = aPronunciation->PhonemeSequence(); + + if ( &phonemeSeq == NULL ) + { + User::Leave( KErrArgument ); + } + + // Check if CSIPronunciation which is given as parameter has the usage counter already + TRAPD( error, TInt temp = aPronunciation->ParameterL( KLexiconReferenceCounter ) ); + TBool counterFound( EFalse ); + + if ( error == KErrNone ) + { + counterFound = ETrue; + } + else + { + counterFound = EFalse; + // New counter + aPronunciation->SetParameterL( KLexiconReferenceCounter, KInitialCounterValue ); + } + + // 1. Insert first based on the phoneme sequence order + TLinearOrder phonemeOrder( CSIPronunciation::ComparePhonemes ); + TRAP( error, iPronunOrder.InsertInOrderL( aPronunciation, phonemeOrder ) ); + + // Store the index for later use + TInt phonemeSeqIndex = iPronunOrder.FindInOrder( aPronunciation, phonemeOrder ); + + // Don't add the same data again + if ( error == KErrAlreadyExists ) + { + // Append counter only if it was not found from the parameter + // This way externalize/internalize works ok, counter won't be touched when + // there is one already + if ( !counterFound ) + { + TInt counterValue( 0 ); + // Just increase the usage counter + CSIPronunciation* existingPronun = iPronunOrder[phonemeSeqIndex]; + counterValue = existingPronun->ParameterL( KLexiconReferenceCounter ); + counterValue++; + existingPronun->SetParameterL( KLexiconReferenceCounter, counterValue ); + } + User::Leave( KErrAlreadyExists ); + } + else + { + User::LeaveIfError( error ); + + TLinearOrder order( CSIPronunciation::Compare ); + + // 2. Insert to the array which is kept in the order of pronunciation id + TRAPD( error, iPronunciationArray.InsertInOrderL( aPronunciation, order ) ); + if ( error != KErrNone ) + { + // Remove previously added element from pronunciation ordered table + iPronunOrder.Remove( phonemeSeqIndex ); + User::Leave( error ); + } + } + +#else + RUBY_DEBUG_BLOCKL("CSILexicon::AddL"); + + // Check if current lexicon already hold maximal alloud number of + // pronunciations or that there is no limit + if( ( KMaxPronunciations != 0 ) && ( iPronunciationArray.Count() > KMaxPronunciations ) ) + { + User::Leave( KErrNoMemory ); + } + // Quick check, if pronun id of the added pronunciation is bigger than the + // last one which is already in array, we can add that to the last + if ( iPronunciationArray.Count() == 0 ) + { + User::LeaveIfError( iPronunciationArray.Append( aPronunciation ) ); + return; + } + else + { + if ( iPronunciationArray[iPronunciationArray.Count() - 1]->PronunciationID() < aPronunciation->PronunciationID() ) + { + User::LeaveIfError( iPronunciationArray.Append( aPronunciation ) ); + return; + } + } + + // Check that pronunciation is not null + const TDesC8& phonemeSeq = aPronunciation->PhonemeSequence(); + + if ( &phonemeSeq == NULL ) + { + User::Leave( KErrArgument ); + } + + // Order function which is used when finding the correct place to insert + TLinearOrder order( CSIPronunciation::Compare ); + + // InsertInOrderL does not allow duplicates, that is what we actually want! + iPronunciationArray.InsertInOrderL( aPronunciation, order ); +#endif // __SIND_LEXICON_OPT + } + +// ----------------------------------------------------------------------------- +// CSILexicon::AddPronunciationToEndL +// Adds pronunciation to end of the array +// ----------------------------------------------------------------------------- +// +void CSILexicon::AddPronunciationToEndL( CSIPronunciation* aPronunciation ) + { + TLinearOrder phonemeOrder( CSIPronunciation::ComparePhonemes ); + TInt error = iPronunciationArray.Append( aPronunciation ); + if ( error != KErrNone ) + { + // Remove previously added element from pronunciation ordered table + iPronunOrder.Remove( iPronunOrder.FindInOrder( aPronunciation, phonemeOrder ) ); + User::Leave( error ); + } + } + +// ----------------------------------------------------------------------------- +// CSILexicon::AtL +// Used to get a pronunciation. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIPronunciation& CSILexicon::AtL( TInt anIndex ) const + { + RUBY_DEBUG_BLOCKL("CSILexicon::AtL"); + if ( anIndex < 0 || anIndex >= Count() ) + { + RUBY_DEBUG2("CSILexicon::AtL index [%d] is ut of bounds. Count [%d]. Leaving with KErrArg", anIndex, Count()); + User::Leave( KErrArgument ); + } + return *( iPronunciationArray[anIndex] ); + } + +// ----------------------------------------------------------------------------- +// CSILexicon::DeleteL +// Deletes a pronunciation with given ID +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSILexicon::DeleteL( TSIPronunciationID aPronunciationID ) + { +#ifdef __SIND_LEXICON_OPT + RUBY_DEBUG_BLOCK( "CSILexicon::DeleteL (SINDE optimized)" ); + + TInt pronunIdIndex = Find( aPronunciationID ); + User::LeaveIfError( pronunIdIndex ); + + CSIPronunciation& pronunciation = AtL( pronunIdIndex ); + + TInt counter = pronunciation.ParameterL( KLexiconReferenceCounter ); + counter--; + + // If counter reaches zero, then pronunciation should be also deleted + if ( counter == 0 ) + { + // Find the index in array ordered by phoneme sequence + TLinearOrder phonemeOrder( CSIPronunciation::ComparePhonemes ); + TInt phonemeSeqIndex = iPronunOrder.FindInOrder( &pronunciation, phonemeOrder ); + User::LeaveIfError( phonemeSeqIndex ); + + // Remove from array ordered by pronunciation + iPronunOrder.Remove( phonemeSeqIndex ); + + // Remove from array ordered by pronunciation id + delete iPronunciationArray[pronunIdIndex]; + iPronunciationArray.Remove( pronunIdIndex ); + } + else + { + pronunciation.SetParameterL( KLexiconReferenceCounter, counter ); + } +#else + RUBY_DEBUG_BLOCK("CSILexicon::DeleteL"); + TInt index = Find( aPronunciationID ); + User::LeaveIfError( index ); + + delete iPronunciationArray[index]; + iPronunciationArray.Remove( index ); +#endif + } + +// ----------------------------------------------------------------------------- +// CSILexicon::Find +// Finds the index of pronunciation with the given ID. +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CSILexicon::Find( TSIPronunciationID aPronunciationID ) const + { + // Order function which is used when finding the correct item + TLinearOrder order( CSIPronunciation::Compare ); + + TInt retVal = KErrNotFound; + + // Construct a 'dummy' CSIPronunciation so that comparison can be done + // against it + CSIPronunciation* pronun = NULL; + TRAPD( error, pronun = CSIPronunciation::NewL( aPronunciationID, 0 ) ); + if ( error ) + { + return error; + } + + // Use binary search since array is kept in the order of pronunciation ids + TRAP( error, retVal = iPronunciationArray.FindInOrderL( pronun, order ) ); + delete pronun; + if ( error ) + { + return error; + } + return retVal; + } + +// ----------------------------------------------------------------------------- +// CSILexicon::Find +// Finds the index of the pronunciation with the given phoneme sequence. +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CSILexicon::Find( const TDesC8& aPhonemeSequence ) const + { +#ifdef __SIND_LEXICON_OPT + // Order function which is used when finding the correct item + TLinearOrder order( CSIPronunciation::ComparePhonemes ); + + TInt retVal = KErrNotFound; + + // Construct a 'dummy' CSIPronunciation so that comparison can be done + // against it + CSIPronunciation* pronun = NULL; + TRAPD( error, + pronun = CSIPronunciation::NewL( 0, 0 ); + pronun->SetPhonemeSequenceL( aPhonemeSequence ); + // Use binary search since array is kept in the order of pronunciation ids + retVal = iPronunOrder.FindInOrderL( pronun, order ); + ); // TRAPD + delete pronun; + if ( error ) + { + return error; + } + + // retVal is index to iPronunOrder array, but what we actually need is + // index to iPronunciationArray + pronun = iPronunOrder[ retVal ]; + + return Find( pronun->PronunciationID() ); +#else + for ( TInt i=0; i < iPronunciationArray.Count(); i++ ) + { + if ( aPhonemeSequence == iPronunciationArray[i]->PhonemeSequence() ) + { + return i; + } + } + return KErrNotFound; +#endif // __SIND_LEXICON_OPT + } + +// ----------------------------------------------------------------------------- +// CSILexicon::Count +// Counts the number of pronunciations. +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CSILexicon::Count() const + { + return iPronunciationArray.Count(); + } + +// ----------------------------------------------------------------------------- +// CSILexicon::ExternalizeL +// Stores the object to the stream. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSILexicon::ExternalizeL( RWriteStream& aWriteStream ) const + { + // Externalization involves so many data structures, + // That I put them to a dedicated class, CSILexiconSerializer. + CSILexiconSerializer* serializer = CSILexiconSerializer::NewLC( *this ); + + aWriteStream.WriteInt32L( KBinaryLexiconID ); + serializer->ExternalizeL( aWriteStream ); + aWriteStream.WriteInt32L( KBinaryLexiconID ); + + CleanupStack::PopAndDestroy( serializer ); + } + +// ----------------------------------------------------------------------------- +// CSILexicon::InternalizeL +// Restores the object from the stream. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSILexicon::InternalizeL( RReadStream& aReadStream ) + { + // Header should be KBinaryLexiconID + if ( aReadStream.ReadInt32L() != KBinaryLexiconID ) + { + User::Leave( KErrCorrupt ); + } + + CSILexiconSerializer* serializer + = CSILexiconSerializer::NewLC( aReadStream ); + + serializer->RestoreL( *this, iLexiconID ); + + CleanupStack::PopAndDestroy( serializer ); + + // Last integer should be KBinaryLexiconID + if ( aReadStream.ReadInt32L() != KBinaryLexiconID ) + { + User::Leave( KErrCorrupt ); + } + } + +/*****************************************************************************/ + +// ----------------------------------------------------------------------------- +// CSIModel::CSIModel +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIModel::CSIModel( const TSIModelID aModelID ) +: iModelID(aModelID), +iAcousticModel(NULL) +{ +} + +// ----------------------------------------------------------------------------- +// CSIModel::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIModel::ConstructL() +{ +} + +// ----------------------------------------------------------------------------- +// CSIModel::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIModel* CSIModel::NewL( const TSIModelID aModelID = 0 ) +{ + CSIModel* self = NewLC( aModelID ); + CleanupStack::Pop( self ); + return self; +} + + +// ----------------------------------------------------------------------------- +// CSIModel::NewLC +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIModel* CSIModel::NewLC( const TSIModelID aModelID = 0 ) +{ + CSIModel* self = new (ELeave) CSIModel( aModelID ); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; +} + +// ----------------------------------------------------------------------------- +// CSIModel::~CSIModel +// Destructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIModel::~CSIModel() +{ + delete iAcousticModel; +} + +// ----------------------------------------------------------------------------- +// CSIModel::SetModelID +// Sets the model ID. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIModel::SetModelID(const TSIModelID aModelID) +{ + iModelID = aModelID; +} + +// ----------------------------------------------------------------------------- +// CSIModel::ModelID +// Returns the model ID. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C TSIModelID CSIModel::ModelID() const +{ + return iModelID; +} + +// ----------------------------------------------------------------------------- +// CSIModel::SetAcousticModel +// Sets the model data. CSIModel takes ownership of the data. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIModel::SetAcousticModel( HBufC8* aAcousticModel) +{ + delete iAcousticModel; + iAcousticModel=aAcousticModel; +} + +// ----------------------------------------------------------------------------- +// CSIModel::AcousticModel +// Used to get the acoustic data of the model. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C TDesC8& CSIModel::AcousticModel() const +{ + return *iAcousticModel; +} + +/*****************************************************************************/ + +// ----------------------------------------------------------------------------- +// CSIModelBank::CSIModelBank +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIModelBank::CSIModelBank( const TSIModelBankID aModelBankID) +: iModelBankID(aModelBankID) +{ +} + +// ----------------------------------------------------------------------------- +// CSIModelBank::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIModelBank::ConstructL() +{ +} + +// ----------------------------------------------------------------------------- +// CSIModelBank::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIModelBank* CSIModelBank::NewL(const TSIModelBankID aModelBankID) +{ + CSIModelBank* self =NewLC(aModelBankID); + CleanupStack::Pop( self ); + return self; +} + + +// ----------------------------------------------------------------------------- +// CSIModelBank::NewLC +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIModelBank* CSIModelBank::NewLC(const TSIModelBankID aModelBankID) +{ + CSIModelBank* self = new (ELeave) CSIModelBank(aModelBankID); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; +} + +// ----------------------------------------------------------------------------- +// CSIModelBank::~CSIModelBank +// Destructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIModelBank::~CSIModelBank() +{ + iModelArray.ResetAndDestroy(); + iModelArray.Close(); +} + +// ----------------------------------------------------------------------------- +// CSIModelBank::ModelBankID +// Returns the ID of the model bank. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C TSIModelBankID CSIModelBank::ModelBankID() const +{ + return iModelBankID; +} + +// ----------------------------------------------------------------------------- +// CSIModelBank::AddL +// Adds a new model to the bank. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIModelBank::AddL( const CSIModel* aModel) +{ + if(Find(aModel->ModelID()) == KErrNotFound) + { + iModelArray.Append(aModel); + } + else + { + User::Leave(KErrAlreadyExists); + + } +} + +// ----------------------------------------------------------------------------- +// CSIModelBank::AtL +// Used to get a model from the bank. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIModel& CSIModelBank::AtL( const TInt anIndex) const +{ + if(anIndex<0 || anIndex >= Count()) + User::Leave(KErrArgument); + + return *(iModelArray[anIndex]); +} + +// ----------------------------------------------------------------------------- +// CSIModelBank::Find +// Finds a model with the given ID. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CSIModelBank::Find(const TSIModelID aModelID) const +{ + for(TInt i=0; i < iModelArray.Count(); i++) + { + if(aModelID == iModelArray[i]->ModelID()) + { + return i; + } + } + return KErrNotFound; +} + +// ----------------------------------------------------------------------------- +// CSIModelBank::DeleteL +// Deletes a model with the given ID. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIModelBank::DeleteL(TSIModelID aModelID) +{ + TInt index = Find(aModelID ); + if ( index != KErrNotFound) + { + delete iModelArray[index]; + iModelArray.Remove(index); + } + + else { + User::Leave( KErrNotFound ); + } +} + +// ----------------------------------------------------------------------------- +// CSIModelBank::Count +// Returns the number of models in the bank. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CSIModelBank::Count() const +{ + return iModelArray.Count(); +} + +/*****************************************************************************/ + +// ----------------------------------------------------------------------------- +// CSIPronunciationInfo::CSIPronunciationInfo +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIPronunciationInfo::CSIPronunciationInfo( RPointerArray aPronunciation, + TLanguage aLanguage ) + : iPronunciationArray( aPronunciation ), + iLanguage( aLanguage ) +{ + // nothing +} + +// ----------------------------------------------------------------------------- +// CSIPronunciationInfo::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIPronunciationInfo::ConstructL() +{ + + CSIParameters::ConstructL(); +} + +// ----------------------------------------------------------------------------- +// CSIPronunciationInfo::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIPronunciationInfo* CSIPronunciationInfo::NewL( RPointerArray aPronunciation ,TLanguage aLanguage ) +{ + CSIPronunciationInfo* self = NewLC( aPronunciation,aLanguage ); + CleanupStack::Pop( self ); + return self; +} + +// ----------------------------------------------------------------------------- +// CSIPronunciationInfo::NewLC +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIPronunciationInfo* CSIPronunciationInfo::NewLC( RPointerArray aPronunciation ,TLanguage aLanguage ) +{ + CSIPronunciationInfo* self = new (ELeave) CSIPronunciationInfo( aPronunciation,aLanguage ); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; +} + +// ----------------------------------------------------------------------------- +// CSIPronunciationInfo::~CSIPronunciationInfo +// Destructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIPronunciationInfo::~CSIPronunciationInfo() +{ + iPronunciationArray.ResetAndDestroy(); + +} + + +// ----------------------------------------------------------------------------- +// CSIPronunciationInfo::SetPronunciationL +// Sets the index and phoneme sequence. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIPronunciationInfo::SetPronunciationL(TInt aIndex, HBufC8* aPronunciation) +{ + if( aIndex < 0 || aIndex > iPronunciationArray.Count() ) + { + // wrong index + User::Leave( KErrArgument ); + } + else if ( aIndex < iPronunciationArray.Count() ) + { + // replace old pronunciation + delete iPronunciationArray[aIndex]; + iPronunciationArray[aIndex] = aPronunciation; + } + else if ( aIndex == iPronunciationArray.Count() ) + { + // append new pronunciation + iPronunciationArray.Append( aPronunciation ); + } +} + +// ----------------------------------------------------------------------------- +// CSIPronunciationInfo::PhonemeSequence +// Return phoneme sequence. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C TDesC8& CSIPronunciationInfo::PronunciationL(TInt aIndex) const +{ + if(aIndex<0 || aIndex >= Count()) + User::Leave(KErrArgument); + + return *(iPronunciationArray[aIndex]); +} + +// ----------------------------------------------------------------------------- +// CSIPronunciationInfo::Language +// Returns language. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C TLanguage CSIPronunciationInfo::Language() const +{ + return iLanguage; +} + +// ----------------------------------------------------------------------------- +// CSIPronunciationInfo::Count +// Returns the number of pronunciations. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CSIPronunciationInfo::Count() const +{ + return iPronunciationArray.Count(); +} + + + +/******************************************************************************/ + +// ----------------------------------------------------------------------------- +// CSITtpWordList::CSITtpWordList +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSITtpWordList::CSITtpWordList() +: +iReserved( NULL ) +{ +} + +// ----------------------------------------------------------------------------- +// CSITtpWordList::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSITtpWordList::ConstructL() +{ +} + +// ----------------------------------------------------------------------------- +// CSITtpWordList::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSITtpWordList* CSITtpWordList::NewL() +{ + CSITtpWordList* self = NewLC(); + CleanupStack::Pop( self ); + return self; +} + +// ----------------------------------------------------------------------------- +// CSITtpWordList::NewLC +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSITtpWordList* CSITtpWordList::NewLC() +{ + CSITtpWordList* self = new ( ELeave ) CSITtpWordList(); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; +} + +// Destructor +// ----------------------------------------------------------------------------- +// CSITtpWordList::~CSITtpWordList +// Destructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSITtpWordList::~CSITtpWordList() +{ + iWordArray.ResetAndDestroy(); + iIndexArray.Close(); + iPronunciationArray.ResetAndDestroy(); +} + +// ----------------------------------------------------------------------------- +// CSITtpWordList::AddL +// Add word to list. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSITtpWordList::AddL( + MDesCArray* aWords) +{ + TInt error = iWordArray.Append( aWords ); + User::LeaveIfError( error ); + +} + +// ----------------------------------------------------------------------------- +// CSITtpWordList::Count +// Return number of words. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CSITtpWordList::Count() const +{ + return iWordArray.Count(); +} + +// ----------------------------------------------------------------------------- +// CSITtpWordList::At +// Give text of given index +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C MDesCArray& CSITtpWordList::AtL( + const TInt aIndex ) const +{ + if(aIndex<0 || aIndex >= Count()) + User::Leave(KErrArgument); + return *(iWordArray[aIndex]); +} + +// ----------------------------------------------------------------------------- +// CSITtpWordList::DeleteL +// Deletes a word. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSITtpWordList::DeleteL(TInt aIndex) { + if(aIndex<0 || aIndex >= Count()) + User::Leave(KErrArgument); + delete iWordArray[aIndex]; + iWordArray.Remove(aIndex); + + // delete pronunciation which index match to given + for ( TInt i(0); i < iIndexArray.Count(); i++ ) + { + if ( iIndexArray[i] == aIndex ) + { + delete iPronunciationArray[i]; + iPronunciationArray.Remove(i); + } + } +} + +// ----------------------------------------------------------------------------- +// CSITtpWordList::SetPronunciationL +// Put pronunciation to given index +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSITtpWordList::AppendPronunciationL( + const TInt aIndex, + CSIPronunciationInfo* aPronunciation ) +{ + TInt error = iPronunciationArray.Append( aPronunciation ); + User::LeaveIfError( error ); + error = iIndexArray.Append( aIndex ); + if ( error ) + { + // remove the added pronunciation + iPronunciationArray.Remove( iPronunciationArray.Count() - 1 ); + User::Leave( error ); + } +} + +// ----------------------------------------------------------------------------- +// CSITtpWordList::GetPronunciationsL +// Give pronunciation information of given index +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSITtpWordList::GetPronunciationsL( + const TInt aIndex, + RPointerArray& aPronunciations ) const +{ + CleanupClosePushL( aPronunciations ); + // clear given array + aPronunciations.Reset(); + + // add pronunciation which index match to given + for ( TInt i(0); i < iIndexArray.Count(); i++ ) + { + if ( iIndexArray[i] == aIndex ) + { + TInt error = aPronunciations.Append( iPronunciationArray[i] ); + User::LeaveIfError( error ); + } + } + CleanupStack::Pop( &aPronunciations ); +} +/*****************************************************************************/ + +// ----------------------------------------------------------------------------- +// CSIResult::CSIResult +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIResult::CSIResult() +: iGrammarID(0), +iRuleID(0), iRuleVariantID(0) +{ +} + +// ----------------------------------------------------------------------------- +// CSIResult::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIResult::ConstructL() +{ +} + +// ----------------------------------------------------------------------------- +// CSIResult::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIResult* CSIResult::NewL() +{ + CSIResult* self = NewLC(); + CleanupStack::Pop( self ); + return self; +} + + + +// ----------------------------------------------------------------------------- +// CSIResult::NewLC +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIResult* CSIResult::NewLC() +{ + CSIResult* self = new (ELeave) CSIResult(); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; +} + +// ----------------------------------------------------------------------------- +// CSIResult::~CSIResult +// Destructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIResult::~CSIResult() +{ + delete iSIPronunciation; +} + +// ----------------------------------------------------------------------------- +// CSIResult::SetGrammarID +// Sets the grammar ID. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIResult::SetGrammarID(const TSIGrammarID aGrammarID) +{ + iGrammarID = aGrammarID; +} + +// ----------------------------------------------------------------------------- +// CSIResult::GrammarID +// Returns the grammar ID. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C TSIGrammarID CSIResult::GrammarID() const +{ + return iGrammarID; +} + +// ----------------------------------------------------------------------------- +// CSIResult::SetRuleID +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIResult::SetRuleID(const TSIRuleID aRuleID) +{ + iRuleID = aRuleID; +} + +// ----------------------------------------------------------------------------- +// CSIResult::RuleID +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C TSIRuleID CSIResult::RuleID() const +{ + return iRuleID; +} + +// ----------------------------------------------------------------------------- +// CSIResult::SetRuleVariantID +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIResult::SetRuleVariantID(const TSIRuleVariantID aRuleVariantID) +{ + iRuleVariantID = aRuleVariantID; +} + +// ----------------------------------------------------------------------------- +// CSIResult::RuleVariantID +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C TSIRuleVariantID CSIResult::RuleVariantID() const +{ + return iRuleVariantID; +} + +// ----------------------------------------------------------------------------- +// CSIResult::SetScore +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIResult::SetScore(const TInt32 aScore) +{ + iScore = aScore; +} + +// ----------------------------------------------------------------------------- +// CSIResult::Score +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt32 CSIResult::Score() const +{ + return iScore; +} + +// ----------------------------------------------------------------------------- +// CSIResult::Pronunciation +// Returns the pronunciation of the recognized word. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIPronunciation& CSIResult::Pronunciation() const +{ + return *iSIPronunciation; +} + +// ----------------------------------------------------------------------------- +// CSIResult::SetPronunciation +// Returns the recognized pronunciation. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIResult::SetPronunciation( CSIPronunciation* aSIPronunciation) +{ + iSIPronunciation=aSIPronunciation; +} + + +/*****************************************************************************/ + + +// ----------------------------------------------------------------------------- +// CSIResultSet::CSIResultSet +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIResultSet::CSIResultSet() +: iAdaptationData(NULL) +{ +} + +// ----------------------------------------------------------------------------- +// CSIResultSet::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIResultSet::ConstructL() +{ +} + +// ----------------------------------------------------------------------------- +// CSIResultSet::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIResultSet* CSIResultSet::NewL() +{ + CSIResultSet* self = NewLC(); + CleanupStack::Pop( self ); + return self; +} + +// ----------------------------------------------------------------------------- +// CSIResultSet::NewLC +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIResultSet* CSIResultSet::NewLC() +{ + CSIResultSet* self = new (ELeave) CSIResultSet(); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; +} + +// ----------------------------------------------------------------------------- +// CSIResultSet::~CSIResultSet +// Destructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIResultSet::~CSIResultSet() +{ + iResultArray.ResetAndDestroy(); + iResultArray.Close(); + delete iAdaptationData ; +} + +// ----------------------------------------------------------------------------- +// CSIResultSet::AddL +// Adds a result to the set. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIResultSet::AddL( const CSIResult* aResult) +{ + TInt error = iResultArray.Append(aResult); + User::LeaveIfError( error ); +} + +// ----------------------------------------------------------------------------- +// CSIResultSet::AtL +// Used to get a result. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIResult& CSIResultSet::AtL(const TInt aIndex) +{ + if(aIndex<0 || aIndex >= Count()) + User::Leave(KErrArgument); + return *(iResultArray[aIndex]); +} + +EXPORT_C const CSIResult& CSIResultSet::AtL(const TInt aIndex) const +{ + if(aIndex<0 || aIndex >= Count()) + User::Leave(KErrArgument); + return *(iResultArray[aIndex]); +} + +// ----------------------------------------------------------------------------- +// CSIResultSet::Count +// Counts the number of results in the set. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CSIResultSet::Count() const +{ + return iResultArray.Count(); +} + +// ----------------------------------------------------------------------------- +// CSIResultSet::DeleteL +// Deletes a result. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIResultSet::DeleteL(TInt aIndex) +{ + if(aIndex<0 || aIndex >= Count()) + User::Leave(KErrArgument); + iResultArray.Remove(aIndex); +} + +// ----------------------------------------------------------------------------- +// CSIResultSet::SetAdaptationData +// Sets the adaptation data. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIResultSet::SetAdaptationData( HBufC8* aAdaptationData ) +{ + delete iAdaptationData; + iAdaptationData =aAdaptationData; +} + +// ----------------------------------------------------------------------------- +// CSIResultSet::AdaptationData +// Gets the adaptation data. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C TDesC8& CSIResultSet::AdaptationData( ) +{ + return *iAdaptationData; +} + +// ----------------------------------------------------------------------------- +// CSIResultSet::ExternalizeL +// Stores the object to the stream. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIResultSet::ExternalizeL( RWriteStream& aWriteStream ) const + { + aWriteStream.WriteInt32L( KBinaryResultSetID ); + + if ( iAdaptationData != NULL ) + { + aWriteStream.WriteInt32L( iAdaptationData->Length() ); + aWriteStream.WriteL( *iAdaptationData ); + } + else{ + aWriteStream.WriteInt32L( 0 ); + } + + aWriteStream.WriteInt32L( iResultArray.Count() ); + + // Write the data + for ( TInt k( 0 ); k < iResultArray.Count(); k++ ) + { + CSIResult* result = iResultArray[ k ]; + const CSIPronunciation& pronun = result->Pronunciation(); + + aWriteStream.WriteInt32L( result->GrammarID() ); + aWriteStream.WriteInt32L( result->RuleID() ); + aWriteStream.WriteInt32L( result->RuleVariantID() ); + aWriteStream.WriteInt32L( result->Score() ); + result->CSIParameters::ExternalizeL( aWriteStream ); + + // !!!! Crashes, if pronunciation is zero. + + // Pronunciations + const TDesC8& seq = pronun.PhonemeSequence(); + TInt length = seq.Length(); + + aWriteStream.WriteInt32L( length ); + aWriteStream.WriteL( seq ); + + aWriteStream.WriteInt32L( pronun.PronunciationID() ); + aWriteStream.WriteInt32L( pronun.ModelBankID() ); + pronun.ExternalizeL( aWriteStream ); + } + + aWriteStream.WriteInt32L( KBinaryResultSetID ); + } + +// ----------------------------------------------------------------------------- +// CSIResultSet::InternalizeL +// Restores the object from the stream. +// (other items were commented in the headers) +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIResultSet::InternalizeL( RReadStream& aReadStream ) + { + if ( iAdaptationData != NULL || iResultArray.Count() > 0 ) + { + User::Leave( KErrInUse ); + } + + if ( aReadStream.ReadInt32L() != KBinaryResultSetID ) + { + User::Leave( KErrCorrupt ); + } + + TInt length = aReadStream.ReadInt32L(); + + if ( length ) + { + iAdaptationData = HBufC8::NewL( length ); + TPtr8 adaptationDataDes = iAdaptationData->Des(); + aReadStream.ReadL( adaptationDataDes, length ); + } + else{ + iAdaptationData = 0; + } + + TInt resultCount = aReadStream.ReadInt32L(); + + for ( TInt k = 0; k < resultCount; k++ ) + { + CSIResult* result = CSIResult::NewLC(); + + result->SetGrammarID ( (TSIGrammarID) aReadStream.ReadInt32L() ); + result->SetRuleID ( (TSIRuleID) aReadStream.ReadInt32L() ); + result->SetRuleVariantID( (TSIRuleVariantID)aReadStream.ReadInt32L() ); + result->SetScore ( aReadStream.ReadInt32L() ); + result->CSIParameters::InternalizeL( aReadStream ); + + // Pronunciations + + TInt length = aReadStream.ReadInt32L(); + HBufC8* seq = HBufC8::NewLC( length ); + + TPtr8 seqPtr = seq->Des(); + aReadStream.ReadL( seqPtr, length ); + + TSIPronunciationID pronunciationID = aReadStream.ReadInt32L(); + TSIModelBankID modelBankID + = (TSIModelBankID)aReadStream.ReadInt32L(); + + CSIPronunciation* pronun + = CSIPronunciation::NewLC( pronunciationID, modelBankID ); + pronun->SetPhonemeSequenceL( *seq ); + + pronun->CSIParameters::InternalizeL( aReadStream ); + + result->SetPronunciation( pronun ); + + AddL( result ); + + CleanupStack::Pop( pronun ); + CleanupStack::PopAndDestroy( seq ); + CleanupStack::Pop( result ); + } + + if ( aReadStream.ReadInt32L() != KBinaryResultSetID ) + User::Leave( KErrCorrupt ); + } + +// void DeleteL(TInt aIndex); + +// End of File