kanjilist.cpp

   1 /*
   2 Project: J-Ben
   3 Author:  Paul Goins
   4 Website: http://www.vultaire.net/software/jben/
   5 License: GNU General Public License (GPL) version 2
   6          (http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt)
   7
   8 File: kanjilist.cpp
   9
  10 This program is free software; you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation; either version 2 of the License, or
  13 (at your option) any later version.
  14
  15 This program is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with this program.  If not, see <http://www.gnu.org/licenses/>
  22 */
  23
  24 #include "kanjilist.h"
  25 #include "global.h"
  26 #include <algorithm>
  27 using namespace std;
  28
  29 KanjiList::KanjiList(const BoostHM<wxChar,string> *kanjiDicHash) {
  30         kanjiHash = kanjiDicHash;
  31 }
  32
  33 #if 0
  34 vector<wxChar>::iterator KanjiList::Find(wxChar c) {
  35         vector<wxChar>::iterator it;
  36         for(it=kanjiList.begin();it!=kanjiList.end();it++) {
  37                 if(*it==c) break;
  38         }
  39         return it;
  40 }
  41 #endif
  42
  43 int KanjiList::AddFromString(const wxString& s) {
  44         int kanjiAdded = 0, len = s.length();
  45         wxChar c;
  46         BoostHM<wxChar,string>::const_iterator it;
  47
  48         for(int i=0;i<len;i++) {
  49                 c = s[i];
  50                 it = kanjiHash->find(c);
  51                 if(it!=kanjiHash->end()) {
  52                         if(find(kanjiList.begin(), kanjiList.end(), c)==kanjiList.end()) {
  53                                 kanjiList.push_back(c);
  54                                 kanjiAdded++;
  55                         }
  56                 }
  57         }
  58
  59         return kanjiAdded;
  60 }
  61
  62 wxString KanjiList::ToString() {
  63         return ToString(0);
  64 }
  65
  66 wxString KanjiList::ToString(int lineWidth) {
  67                 wxString result;
  68                 int lineWidthCounter=0;
  69                 int len = kanjiList.size();
  70                 for(int i=0;i<len;i++) {
  71                         result.append(kanjiList[i]);
  72                         if(lineWidth>0) {
  73                                 lineWidthCounter++;
  74                                 if(lineWidthCounter>=lineWidth) {
  75                                         result.append(_T('\n'));
  76                                         lineWidthCounter=0;
  77                                 }
  78                         }
  79                 }
  80                 return result;
  81 }
  82
  83 void KanjiList::Clear() {
  84         kanjiList.clear();
  85 }
  86
  87 int KanjiList::AddByGrade(int lowGrade, int highGrade) {
  88         wxString kanjiStr;
  89         int grade;
  90
  91         for(BoostHM<wxChar,string>::const_iterator ki=kanjiHash->begin(); ki!=kanjiHash->end(); ki++) {
  92                 grade = jben->kdict->GetIntField(ki->first, _T("G"));
  93                 if(grade>=lowGrade &&
  94                   (grade<=highGrade || highGrade==0))
  95                         kanjiStr.append(ki->first);
  96         }
  97
  98         return AddFromString(kanjiStr);
  99 }
 100
 101 int KanjiList::AddByFrequency(int lowFreq, int highFreq) {
 102         wxString kanjiStr;
 103         int freq;
 104
 105         for(BoostHM<wxChar,string>::const_iterator ki=kanjiHash->begin(); ki!=kanjiHash->end(); ki++) {
 106                 freq = jben->kdict->GetIntField(ki->first, _T("F"));
 107                 if(freq>=lowFreq && freq<=highFreq)
 108                         kanjiStr.append(ki->first);
 109         }
 110
 111         return AddFromString(kanjiStr);
 112 }
 113
 114 int KanjiList::Size() {return kanjiList.size();}
 115
 116 void KanjiList::InplaceMerge(vector<wxChar>& v, BoostHM<wxChar,int>& indexer, int start, int middle, int end) {
 117         /* Merge is implemented as a bubble sort started at halfway
 118            (since we know the first whole half is already sorted) */
 119         int i, highIndex;
 120         wxChar temp;
 121         i = highIndex = middle;
 122         while(i<end) {
 123                 if(i>0 && (indexer[v[i]] < indexer[v[i-1]])) {
 124                         temp = v[i-1];
 125                         v[i-1] = v[i];
 126                         v[i] = temp;
 127                         i--;
 128                 } else {
 129                         highIndex++;
 130                         i=highIndex;
 131                 }
 132         }
 133 }
 134
 135 /*
 136 SortKanjiList sorts the currently loaded kanji list based upon a specified
 137 KANJIDIC field, like F (frequency) or G (jouyou grade).  Sorting is done
 138 via a merged sort.  This might be overkill, but I wanted to try doing
 139 it, so I did.
 140 */
 141 void KanjiList::Sort(int sortType, bool reverseOrder) {
 142         int totalSize = kanjiList.size();
 143         if(totalSize<=1) return;  /* Size 0 or 1 list is already sorted */
 144
 145         myCharIndexer = new BoostHM<wxChar,int>;
 146         myCharIndexer->clear();
 147         vector<wxChar>::iterator vi;
 148
 149         wxString fieldMarker;
 150         switch(sortType) {
 151         case ST_GRADE:
 152                 fieldMarker=_T("G");
 153                 break;
 154         case ST_FREQUENCY:
 155                 fieldMarker=_T("F");
 156                 break;
 157         default:
 158                 fieldMarker=_T("INVALID");
 159         }
 160
 161         /* Create index based on the sort type */
 162         int value;
 163         for(vi=kanjiList.begin();vi!=kanjiList.end();vi++) {
 164                 value = jben->kdict->GetIntField(*vi, fieldMarker);
 165                 if(value==-1) value=INT_MAX;
 166                 myCharIndexer->assign(*vi, value);
 167         }
 168
 169         /* Sort our data based upon the stored key in the hash table */
 170         /* This code, a merge sort, was created based upon code at:
 171            http://en.wikipedia.org/wiki/Merge_sort#C.2B.2B_implementation
 172            These pages were referred to:
 173            http://www.cppreference.com/cppalgorithm/merge.html
 174            http://www.cppreference.com/cppalgorithm/inplace_merge.html
 175
 176            The below is an original implementation designed to work with a wxHashMap and vector<wxChar>. */
 177         int rangeSize, rangeStart;
 178         for(rangeSize=1; rangeSize<totalSize; rangeSize *= 2) {
 179                 for(rangeStart=0; rangeStart<totalSize-rangeSize; rangeStart += rangeSize*2) {
 180                         /* Our range sort function is HERE */
 181                         InplaceMerge(
 182                           kanjiList,
 183                           *myCharIndexer,
 184                           rangeStart,
 185                           rangeStart + rangeSize,
 186                           min(rangeStart + rangeSize*2, totalSize));
 187                 }
 188         }
 189
 190 #if 0
 191         /* DEBUG ONLY: Check that the sort works as intended! */
 192         if(totalSize>0) {
 193                 int lastVal = (*myCharIndexer)[kanjiList[0]];
 194                 for(int i=1;i<totalSize;i++) {
 195                         value = (*myCharIndexer)[kanjiList[i]];
 196                         if(value<lastVal)
 197                                 fprintf(stderr, "Error! Index %d has value of %d, while %d has value of %d!\n", i, value, i-1, lastVal);
 198                         else
 199                                 printf("%d=%d\t", i, value);
 200                         lastVal = value;
 201                 }
 202         }
 203 #endif
 204
 205         delete myCharIndexer;
 206 }
 207
 208 #if 0
 209 wxChar KanjiList::GetCharByIndex(unsigned int index) {
 210         return operator[](index);
 211 }
 212 #endif
 213
 214 wxChar KanjiList::operator[](unsigned int index) {
 215         if(index<kanjiList.size()) return kanjiList[index];
 216         return _T('\0');
 217 }
 218
 219 int KanjiList::GetIndexByChar(wxChar c) {
 220         int i, len = kanjiList.size();
 221         for(i=0;i<len;i++)
 222                 if(kanjiList[i]==c) return i;
 223         return -1;
 224 }
 225
 226 vector<wxChar>& KanjiList::GetVector() {return kanjiList;}