logsui/logscntfinder/src/logscntentry.cpp
changeset 21 2f0af9ba7665
parent 17 90fe74753f71
equal deleted inserted replaced
18:acd4e87b24b4 21:2f0af9ba7665
   354 // LogsCntEntry::match()
   354 // LogsCntEntry::match()
   355 // -----------------------------------------------------------------------------
   355 // -----------------------------------------------------------------------------
   356 //
   356 //
   357 bool LogsCntEntry::match( const QString& pattern ) const
   357 bool LogsCntEntry::match( const QString& pattern ) const
   358 {
   358 {
   359     bool match = false;
   359     bool match = false; 
   360     if ( pattern.length() > 0 ) {
   360     if ( pattern.length() > 0 ) {
   361         LogsPredictiveTranslator* translator = LogsPredictiveTranslator::instance();
   361 
       
   362         match = type() == EntryTypeHistory && 
       
   363                 mPhoneNumber.mTranslatedText.startsWith( pattern );
   362         
   364         
   363         QString modifiedPattern = pattern;
   365         if ( !match ) {
   364         modifiedPattern = translator->trimPattern( modifiedPattern, true );
   366             LogsCntTextList nameArray = mFirstName + mLastName; //with empties
   365         
   367             LogsCntTokenArray* tokenArray = reinterpret_cast<LogsCntTokenArray*>( &nameArray );
   366         //direct match with phone number is enough
   368             LogsCntTokenIterator names( *tokenArray );
   367         match = ( type() == EntryTypeHistory && 
   369             match = LogsPredictiveTranslator::instance()->match( pattern, names );
   368                   mPhoneNumber.mTranslatedText.startsWith( pattern ) ) ||
       
   369                 doSimpleMatch( modifiedPattern );
       
   370         
       
   371         if (!match && translator->hasPatternSeparators( modifiedPattern ) ) {
       
   372             QStringList patternArray = translator->patternTokens( modifiedPattern );
       
   373             match = doComplexMatch( patternArray );
       
   374             if (!match ) {
       
   375                 for(int i=0;i<patternArray.length();i++ ) {
       
   376                     translator->trimPattern( patternArray[i] );
       
   377                 }
       
   378                 match = doComplexMatch( patternArray );
       
   379             }
       
   380         }
   370         }
   381     }
   371     }
   382     
   372     
   383     return match;
   373     return match;
   384 }
   374 }
   385 
   375 
   386 // -----------------------------------------------------------------------------
       
   387 // LogsCntEntry::doSimpleMatch()
       
   388 // -----------------------------------------------------------------------------
       
   389 //
       
   390 bool LogsCntEntry::doSimpleMatch( const QString& pattern ) const
       
   391 {
       
   392     LogsCntTextList nameArray = mFirstName + mLastName; //with empties
       
   393     QListIterator<LogsCntText> names( nameArray ); 
       
   394     int matchCount = 0;
       
   395 
       
   396     while( names.hasNext() && !matchCount ) {
       
   397         matchCount = (int)names.next().mTranslatedText.startsWith( pattern );
       
   398     }
       
   399 
       
   400     return matchCount > 0;
       
   401 }
       
   402 
       
   403 
       
   404 // -----------------------------------------------------------------------------
       
   405 // LogsCntEntry::doComplexMatch()
       
   406 // -----------------------------------------------------------------------------
       
   407 //
       
   408 bool LogsCntEntry::doComplexMatch( const QStringList& patternArray ) const
       
   409 {
       
   410     const bool zero = false;
       
   411 
       
   412     LogsCntTextList nameArray = mFirstName + mLastName; //with empties
       
   413 
       
   414     int targetMatchCount = patternArray.count();
       
   415     int namesCount = nameArray.count();
       
   416 
       
   417     //if pattern has more tokens than name(s), it is a missmatch
       
   418     if ( namesCount < targetMatchCount ) {
       
   419         return false;
       
   420     }
       
   421 
       
   422     QListIterator<LogsCntText> names( nameArray ); 
       
   423     QListIterator<QString> patterns( patternArray );
       
   424     QVector<bool> matchVector(targetMatchCount, zero );
       
   425     int currentPattern = 0;
       
   426     int matchCount = 0;
       
   427     bool match = false;
       
   428     
       
   429     while( names.hasNext() && matchCount < targetMatchCount ) {
       
   430         LogsCntText name = names.next();
       
   431         currentPattern = 0;
       
   432         patterns.toFront();
       
   433         match = false;
       
   434         while ( !name.mText.isEmpty() && 
       
   435                  patterns.hasNext() && !match ) {
       
   436             QString pattern = patterns.next();
       
   437             //unique match check
       
   438             if ( !matchVector.at( currentPattern ) ) {
       
   439                 match = matchVector[ currentPattern ] 
       
   440                       = name.mTranslatedText.startsWith( pattern );
       
   441                 matchCount = match ? matchCount+1 : matchCount;
       
   442             }
       
   443             currentPattern++;
       
   444         }
       
   445     }
       
   446     return matchCount >= targetMatchCount;
       
   447 
       
   448     }
       
   449     
       
   450     
   376     
   451 
   377 
   452 // -----------------------------------------------------------------------------
   378 // -----------------------------------------------------------------------------
   453 // LogsCntEntry::isCached()
   379 // LogsCntEntry::isCached()
   454 // -----------------------------------------------------------------------------
   380 // -----------------------------------------------------------------------------