FCL/sf/mw/hb: comparison src/hbcore/inputfw/hbinputextrauserdictionary.cpp

equal deleted inserted replaced

-:730c025d4b77
+:f378acbc9cfb
 **
 ** If you have questions regarding the use of this file, please contact
 ** Nokia at developer.feedback@nokia.com.
 **
 ****************************************************************************/
+#include "hbinputextrauserdictionary.h"
+#include "hbinputextrauserdictionary_p.h"
 #include <qbytearray.h> // For memmove()
 #include <QFile>
 #include <QDir>
 #include <QSharedMemory>
 #include <QVector>
-#include "hbinputextrauserdictionary.h"
-#include "hbinputextrauserdictionary_p.h"
 #include "hbinputsettingproxy.h"
 const int HbExtraDictMaxFrequency = 255;
 /*!
 /// @cond
 bool HbExtraUserDictionaryPrivate::createSharedBlock(int aSize)
 {
 if (sharedMemory.isAttached()) {
 return true;
 }
 if (id == 0) {
 return false;
 }
 sharedMemory.setKey(name());
 if (!sharedMemory.attach()) {
 if (sharedMemory.error() != QSharedMemory::NotFound) {
 qDebug("HbExtraUserDictionaryPrivate: QSharedMemory::attached returned error %d", sharedMemory.error());
 return false;
 }
 dataHeader()->numWords = 0;
 dataHeader()->numUsers = 0;
 dataHeader()->modified = false;
 dataHeader()->dataSize = 0;
 }
 dataHeader()->numUsers++;
 return true;
 }
 QString HbExtraUserDictionaryPrivate::name() const
 {
 QString num;
 return HbInputSettingProxy::extraDictionaryPath() + QDir::separator() + name() + QString(KExtraFileExt);
 }
 bool HbExtraUserDictionaryPrivate::save(QString fileName)
 {
 QFile file(fileName);
-if (file.open( QIODevice::WriteOnly )) {
+if (file.open(QIODevice::WriteOnly)) {
-file.write((char*)&id, sizeof(int));
+file.write((char *)&id, sizeof(int));
 if (sharedMemory.isAttached()) {
-file.write((char*)sharedMemory.data(), KExtraUDBlockSize);
+file.write((char *)sharedMemory.data(), KExtraUDBlockSize);
 }
 file.close();
 dataHeader()->modified = false;
 return true;
 }
 return false;
 }
-int HbExtraUserDictionaryPrivate::findFirstMatch(int start, int end, const QString& searchString, int knownMatch, Qt::CaseSensitivity caseSensitivity) const
+int HbExtraUserDictionaryPrivate::findFirstMatch(int start, int end, const QString &searchString, int knownMatch, Qt::CaseSensitivity caseSensitivity) const
 {
 HbExtraUDDirectoryEntry *dir = directory();
 QChar *data = dataArea();
 if (start >= end) {
 int half = (start + end) / 2;
 if (QString(&data[dir[half].start], dir[half].length).startsWith(searchString, Qt::CaseInsensitive)) {
 knownMatch = half;
 return findFirstMatch(start, half, searchString, knownMatch, caseSensitivity);
 }
 if (compareWords(half, searchString, caseSensitivity) > 0) {
 return findFirstMatch(half + 1, end, searchString, knownMatch, caseSensitivity);
 }
 // First move trailing directory entries and the beginning of the data area
 // by size of one dictionary entry item.
 memmove((char *)&dir[index], (char *)&dir[index + 1], (dataHeader()->numWords - index) * sizeof(HbExtraUDDirectoryEntry) + start * sizeof(QChar));
 // Then move trailing part of the data area.
-memmove(((char*)&data[start]) - sizeof(HbExtraUDDirectoryEntry), (char*)&data[start + length], (dataHeader()->dataSize - (start + length)) * 2);
+memmove(((char *)&data[start]) - sizeof(HbExtraUDDirectoryEntry), (char *)&data[start + length], (dataHeader()->dataSize - (start + length)) * 2);
 // Update word count.
 dataHeader()->numWords--;
 dataHeader()->dataSize -= length;
 dataHeader()->modified = true;
 // Then update remaining dictionary entries.
 const int rounds = dataHeader()->numWords;
 for (int i = index; i < rounds; i++) {
 dir[i].start -= length;
 }
 }
-void HbExtraUserDictionaryPrivate::addEntry(int index, const QString& newWord)
+void HbExtraUserDictionaryPrivate::addEntry(int index, const QString &newWord)
 {
 HbExtraUDDirectoryEntry *dir = directory();
 QChar *data = dataArea();
 const int origNumWords = dataHeader()->numWords;
 if (origNumWords > 0) {
 if (index < origNumWords) {
 // First move the trailing part of the data area to make space for the new word.
-memmove((char*)&data[dir[index].start + newWord.size()] + sizeof(HbExtraUDDirectoryEntry),
+memmove((char *)&data[dir[index].start + newWord.size()] + sizeof(HbExtraUDDirectoryEntry),
-(char*)(&data[dir[index].start]),
+(char *)(&data[dir[index].start]),
 (dataHeader()->dataSize - dir[index].start) * 2);
 // Then move the trailing part of the dictionary and the leading part of the data area.
-memmove((char*)(&dir[index + 1]),
+memmove((char *)(&dir[index + 1]),
-(char*)(&dir[index]),
+(char *)(&dir[index]),
 ((dataHeader()->numWords - index) * sizeof(HbExtraUDDirectoryEntry)) + (dir[index].start * 2));
 } else {
 // This will be the last one. Just make room for new directory entry.
-memmove((char*)data + sizeof(HbExtraUDDirectoryEntry),
+memmove((char *)data + sizeof(HbExtraUDDirectoryEntry),
-(char*)data,
+(char *)data,
 dataHeader()->dataSize * 2);
 }
 }
 // Update word count.
 dataHeader()->numWords++;
 dataHeader()->dataSize += newWord.size();
 }
 // Then update remaining dictionary entries.
 const int rounds = dataHeader()->numWords;
 for (int i = index + 1; i < rounds; i++) {
 dir[i].start += newWord.size();
 }
 }
-int HbExtraUserDictionaryPrivate::findWord(int startIndex, int endIndex, const QString& newWord, Qt::CaseSensitivity caseSensitivity) const
+int HbExtraUserDictionaryPrivate::findWord(int startIndex, int endIndex, const QString &newWord, Qt::CaseSensitivity caseSensitivity) const
 {
 if (startIndex >= endIndex) {
 if (startIndex < dataHeader()->numWords && compareWords(startIndex, newWord, caseSensitivity) == 0) {
 return startIndex;
 }
 } else {
 return findWord(startIndex, half, newWord, caseSensitivity);
 }
 }
-int HbExtraUserDictionaryPrivate::findIndexForNewWord(int start, int end, const QString& newWord) const
+int HbExtraUserDictionaryPrivate::findIndexForNewWord(int start, int end, const QString &newWord) const
 {
 if (start >= end) {
 if (dataHeader()->numWords == 0) {
 return 0;
 }
 } else {
 return findIndexForNewWord(start, half, newWord);
 }
 }
-int HbExtraUserDictionaryPrivate::compareWords(int index, const QString& otherWord, Qt::CaseSensitivity caseSensitivity) const
+int HbExtraUserDictionaryPrivate::compareWords(int index, const QString &otherWord, Qt::CaseSensitivity caseSensitivity) const
 {
 HbExtraUDDirectoryEntry *dir = directory();
 QChar *data = dataArea();
 const int start = dir[index].start;
 const int rounds = (dir[index].length > otherWord.size() ? otherWord.size() : dir[index].length);
 if (caseSensitivity == Qt::CaseSensitive) {
 for (int i = 0; i < rounds; i++) {
 if (data[start + i] == otherWord[i]) {
 continue;
 }
 if (otherWord[i] > data[start + i]) {
 return 1;
 }
 return -1;
 }
 } else {
 for (int i = 0; i < rounds; i++) {
 if (data[start + i].toCaseFolded() == otherWord[i].toCaseFolded()) {
 continue;
 }
 if (otherWord[i].toCaseFolded() > data[start + i].toCaseFolded()) {
 return 1;
 }
 return -1;
 }
 }
 if (dir[index].length == otherWord.size()) {
 return 0;  // Match!
 }
 }
 return -1;
 }
-bool HbExtraUserDictionaryPrivate::hasEnoughSpaceForNewWord(const QString& newWord) const
+bool HbExtraUserDictionaryPrivate::hasEnoughSpaceForNewWord(const QString &newWord) const
 {
 if ((unsigned int)dataAreaSize() - (dataHeader()->dataSize * 2) >= (newWord.size() * 2) + sizeof(HbExtraUDDirectoryEntry)) {
 return true;
 }
 return d->id;
 }
 /*!
 Adds single word to the database. Returns true if there was enough space for new
-word and the word was succesfully added. Returns false if word already
+word and the word was successfully added. Returns false if word already
 exists.
 \sa addWords
 \sa removeWord
 */
-bool HbExtraUserDictionary::addWord(const QString& newWord, HbPredictionCallback* callback)
+bool HbExtraUserDictionary::addWord(const QString &newWord, HbPredictionCallback *callback)
 {
 Q_UNUSED(callback);
 Q_D(HbExtraUserDictionary);
 d->lock();
 }
 if (newWord.size() < KExtraUserDictionaryMaxWordLength &&
 d->hasEnoughSpaceForNewWord(newWord) &&
 d->dataHeader()->numWords < KExtraUserDictionaryMaxWords) {
 int newIndex = d->findIndexForNewWord(0, d->dataHeader()->numWords - 1, newWord);
 d->addEntry(newIndex, newWord);
 d->unlock();
 return true;
 }
 d->unlock();
 return false;
 }
 successfully added to the database.
 \sa addWord
 \sa removeWord
 */
-bool HbExtraUserDictionary::addWords(const QStringList& wordList)
+bool HbExtraUserDictionary::addWords(const QStringList &wordList)
 {
 bool ret = true;
 for (int i = 0; i < wordList.count(); i++) {
 ret &= addWord(wordList[i]);
 Removes a word from the database. Returns true if the word was found and removed.
 \sa addWord
 \sa addWords
 */
-bool HbExtraUserDictionary::removeWord(const QString& toBeRemoved)
+bool HbExtraUserDictionary::removeWord(const QString &toBeRemoved)
 {
 Q_D(HbExtraUserDictionary);
 d->lock();
 int index = d->findWord(0, d->dataHeader()->numWords - 1, toBeRemoved, Qt::CaseInsensitive);
 if (index >= 0) {
 d->removeEntry(index);
 d->unlock();
 return true;
 }
 d->unlock();
 return false;
 }
 /*!
 Returns all the dictionary words that begin with contents of searchString.
 Search is case insensitive. Empty string will match to all words.
 */
-QStringList HbExtraUserDictionary::findMatches(const QString& searchString, bool sortByFrequency, Qt::CaseSensitivity caseSensitivity)
+QStringList HbExtraUserDictionary::findMatches(const QString &searchString, bool sortByFrequency, Qt::CaseSensitivity caseSensitivity)
 {
 Q_UNUSED(caseSensitivity);  // Will be taken into use...
 Q_D(HbExtraUserDictionary);
 QVector<unsigned char> frequencies;
 }
 /*!
 Returns pointer to host prediction engine.
 */
-HbPredictionBase* HbExtraUserDictionary::hostEngine() const
+HbPredictionBase *HbExtraUserDictionary::hostEngine() const
 {
 Q_D(const HbExtraUserDictionary);
 return d->hostEngine;
 }
 /*!
 Sets host prediction engine.
 */
-void HbExtraUserDictionary::setHostEngine(HbPredictionBase* host)
+void HbExtraUserDictionary::setHostEngine(HbPredictionBase *host)
 {
 Q_D(HbExtraUserDictionary);
 d->hostEngine = host;
 }
 /*!
 Loads dictionary from disk.
 */
-bool HbExtraUserDictionary::load(const QString& nameOfTheFile)
+bool HbExtraUserDictionary::load(const QString &nameOfTheFile)
 {
 Q_D(HbExtraUserDictionary);
 QString realFileName = nameOfTheFile;
 if (realFileName.size() == 0) {
 realFileName = fileName();
 }
 if (attach()) {
 d->lock();
 QFile file(realFileName);
-if (file.open( QIODevice::ReadOnly )) {
+if (file.open(QIODevice::ReadOnly)) {
 int numUsers = d->dataHeader()->numUsers;
-file.read((char*)&d->id, sizeof(int));
+file.read((char *)&d->id, sizeof(int));
-file.read((char*)d->sharedMemory.data(), KExtraUDBlockSize);
+file.read((char *)d->sharedMemory.data(), KExtraUDBlockSize);
 file.close();
 d->dataHeader()->numUsers = numUsers;
 d->unlock();
 return true;
 }
 d->unlock();
 }
 return false;
 }
 /*!
 Saves dictionary to disk. If no file name is give, fileName() will
 be used.
 \sa fileName
 */
-bool HbExtraUserDictionary::save(const QString& nameOfTheFile)
+bool HbExtraUserDictionary::save(const QString &nameOfTheFile)
 {
 Q_D(HbExtraUserDictionary);
 QString realFileName = nameOfTheFile;
 if (realFileName.size() == 0) {
 realFileName = fileName();
 }
 bool ret = false;
 d->lock();
 ret = d->save(realFileName);
 d->unlock();
 return ret;
 }
 /*!
 Sets dictionary id.
 */
 This method is provided for sake of efficiency for those who need direct access and know what they are doing.
 \sa rawDataAreaSize
 \sa directory
 */
-QChar* HbExtraUserDictionary::rawDataArea() const
+QChar *HbExtraUserDictionary::rawDataArea() const
 {
 Q_D(const HbExtraUserDictionary);
 return d->dataArea();
 }
 }
 /*!
 Increases word frequency counter for given word if it is in the dictionary.
 */
-void HbExtraUserDictionary::incrementUseCount(const QString& word)
+void HbExtraUserDictionary::incrementUseCount(const QString &word)
 {
 Q_D(const HbExtraUserDictionary);
 if (d->dataHeader()->numWords) {
 HbExtraUDDirectoryEntry *dir = d->directory();
 int first = d->findFirstMatch(0, d->dataHeader()->numWords - 1, word);
 if (first >= 0 && dir[first].frequency < HbExtraDictMaxFrequency) {
 dir[first].frequency++;
 d->dataHeader()->modified = true;
 }
 }
 }
 /*!
 Returns true if given word exits in the dictionary.
 */
-bool HbExtraUserDictionary::hasWord(const QString& word, Qt::CaseSensitivity caseSensitivity) const
+bool HbExtraUserDictionary::hasWord(const QString &word, Qt::CaseSensitivity caseSensitivity) const
 {
 Q_D(const HbExtraUserDictionary);
 if (d->dataHeader()->numWords) {
 QChar *data = d->dataArea();
 HbExtraUDDirectoryEntry *dir = d->directory();
-int first = d->findFirstMatch(0, d->dataHeader()->numWords - 1, word,-1, caseSensitivity);
+int first = d->findFirstMatch(0, d->dataHeader()->numWords - 1, word, -1, caseSensitivity);
 if (first >= 0) {
 if (caseSensitivity == Qt::CaseSensitive) {
 if (QString(&data[dir[first].start], dir[first].length) == word) {
 return true;
+}
+const int rounds = d->dataHeader()->numWords;
+for (int i = first + 1; i <= rounds; i++) {
+QString candidate(&data[dir[i].start], dir[i].length);
+if (candidate.startsWith(word, Qt::CaseInsensitive)) {
+if (candidate == word) {
+return true;
+}
+} else {
+break;
 }
+}
-const int rounds = d->dataHeader()->numWords;
-for (int i = first + 1; i <= rounds; i++) {
-QString candidate(&data[dir[i].start], dir[i].length);
-if (candidate.startsWith(word, Qt::CaseInsensitive)) {
-if (candidate == word) {
-return true;
-}
-} else {
-break;
-}
-}
 } else {
 if (QString(&data[dir[first].start], dir[first].length).toCaseFolded() == word.toCaseFolded()) {
 return true;
 }
 const int rounds = d->dataHeader()->numWords;
 }
 } else {
 break;
 }
 }
 }
 }
 }
 return false;
 }

branch	GCC_SURGE
changeset 15	f378acbc9cfb
parent 6	c3690ec91ef8
child 28	b7da29130b0e
child 34	ed14f46c0e55