diff -r 8ce15fced3a6 -r cad71a31b7fc srsf/sispeechrecognitiondata/src/nsssispeechrecognitiondatadevasr.cpp --- a/srsf/sispeechrecognitiondata/src/nsssispeechrecognitiondatadevasr.cpp Thu Aug 19 09:56:14 2010 +0300 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,2575 +0,0 @@ -/* -* 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