Get rid of pointless double-caching.

[Dictionary.git] / src / com / hughes / android / dictionary / engine / Index.java

diff --git a/src/com/hughes/android/dictionary/engine/Index.java b/src/com/hughes/android/dictionary/engine/Index.java
index 63867081a6623aa60ec344ce33b8b3fea2d562df..88aa22d05587e68c1355a1116a38548de3570c5b 100644 (file)
--- a/src/com/hughes/android/dictionary/engine/Index.java
+++ b/src/com/hughes/android/dictionary/engine/Index.java
@@ -13,7 +13,7 @@
 // limitations under the License.
 
 /**
- * 
+ *
  */
 
 package com.hughes.android.dictionary.engine;
@@ -29,7 +29,7 @@ import com.hughes.util.raf.RAFSerializable;
 import com.hughes.util.raf.RAFSerializer;
 import com.hughes.util.raf.SerializableSerializer;
 import com.hughes.util.raf.UniformRAFList;
-import com.ibm.icu.text.Collator;
+import java.text.Collator;
 import com.ibm.icu.text.Transliterator;
 
 import java.io.DataInput;
@@ -41,10 +41,10 @@ import java.util.AbstractList;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.EnumMap;
 import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -105,8 +105,7 @@ public final class Index implements RAFSerializable<Index> {
      */
     public synchronized Transliterator normalizer() {
         if (normalizer == null) {
-            normalizer = Transliterator
-                    .createFromRules("", normalizerRules, Transliterator.FORWARD);
+            normalizer = TransliteratorManager.get(normalizerRules);
         }
         return normalizer;
     }
@@ -116,7 +115,7 @@ public final class Index implements RAFSerializable<Index> {
      * normalizations.
      */
     public NormalizeComparator getSortComparator() {
-        return new NormalizeComparator(normalizer(), sortLanguage.getCollator());
+        return new NormalizeComparator(normalizer(), sortLanguage.getCollator(), dict.dictFileVersion);
     }
 
     public Index(final Dictionary dict, final DataInput inp) throws IOException {
@@ -135,9 +134,15 @@ public final class Index implements RAFSerializable<Index> {
             mainTokenCount = raf.readInt();
         }
         sortedIndexEntries = CachingList.create(
-                RAFList.create(raf, indexEntrySerializer, raf.getFilePointer(), dict.dictFileVersion,
-                dict.dictFileVersion >= 7 ? 16 : 1, dict.dictFileVersion >= 7), CACHE_SIZE);
-        if (dict.dictFileVersion >= 4) {
+                RAFList.create(raf, indexEntrySerializer, raf.getFilePointer(),
+                               dict.dictFileVersion, dict.dictInfo + " idx " + languageCode + ": "), CACHE_SIZE);
+        if (dict.dictFileVersion >= 7) {
+            int count = StringUtil.readVarInt(raf);
+            stoplist = new HashSet<String>(count);
+            for (int i = 0; i < count; ++i) {
+                stoplist.add(raf.readUTF());
+            }
+       } else if (dict.dictFileVersion >= 4) {
             stoplist = new SerializableSerializer<Set<String>>().read(raf);
         } else {
             stoplist = Collections.emptySet();
@@ -158,8 +163,11 @@ public final class Index implements RAFSerializable<Index> {
         if (dict.dictFileVersion >= 2) {
             raf.writeInt(mainTokenCount);
         }
-        RAFList.write(raf, sortedIndexEntries, indexEntrySerializer, 16, true);
-        new SerializableSerializer<Set<String>>().write(raf, stoplist);
+        RAFList.write(raf, sortedIndexEntries, indexEntrySerializer, 32, true);
+        StringUtil.writeVarInt(raf, stoplist.size());
+        for (String i : stoplist) {
+            raf.writeUTF(i);
+        }
         UniformRAFList.write(raf, rows, new RowBase.Serializer(this), 3 /* bytes per entry */);
     }
 
@@ -182,17 +190,14 @@ public final class Index implements RAFSerializable<Index> {
     };
 
     public static final class IndexEntry implements RAFSerializable<Index.IndexEntry> {
-        private final Index index;
         public final String token;
         private final String normalizedToken;
         public final int startRow;
         public final int numRows; // doesn't count the token row!
         public List<HtmlEntry> htmlEntries;
-        private int[] htmlEntryIndices;
 
         public IndexEntry(final Index index, final String token, final String normalizedToken,
                 final int startRow, final int numRows) {
-            this.index = index;
             assert token.equals(token.trim());
             assert token.length() > 0;
             this.token = token;
@@ -203,7 +208,6 @@ public final class Index implements RAFSerializable<Index> {
         }
 
         public IndexEntry(final Index index, final DataInput raf) throws IOException {
-            this.index = index;
             token = raf.readUTF();
             if (index.dict.dictFileVersion >= 7) {
                 startRow = StringUtil.readVarInt(raf);
@@ -214,27 +218,31 @@ public final class Index implements RAFSerializable<Index> {
             }
             final boolean hasNormalizedForm = raf.readBoolean();
             normalizedToken = hasNormalizedForm ? raf.readUTF() : token;
-            htmlEntryIndices = null;
             if (index.dict.dictFileVersion >= 7) {
                 int size = StringUtil.readVarInt(raf);
-                htmlEntryIndices = new int[size];
-                for (int i = 0; i < size; ++i) {
-                    htmlEntryIndices[i] = StringUtil.readVarInt(raf);
-                }
-                this.htmlEntries = CachingList.create(new AbstractList<HtmlEntry>() {
-                    @Override
-                    public HtmlEntry get(int i) {
-                        return index.dict.htmlEntries.get(htmlEntryIndices[i]);
-                    }
-                    @Override
-                    public int size() {
-                        return htmlEntryIndices.length;
+                if (size == 0) {
+                    this.htmlEntries = Collections.emptyList();
+                } else {
+                    final int[] htmlEntryIndices = new int[size];
+                    for (int i = 0; i < size; ++i) {
+                        htmlEntryIndices[i] = StringUtil.readVarInt(raf);
                     }
-                    }, 1);
+                    this.htmlEntries = new AbstractList<HtmlEntry>() {
+                        @Override
+                        public HtmlEntry get(int i) {
+                            return index.dict.htmlEntries.get(htmlEntryIndices[i]);
+                        }
+                        @Override
+                        public int size() {
+                            return htmlEntryIndices.length;
+                        }
+                        };
+                }
             } else if (index.dict.dictFileVersion >= 6) {
                 this.htmlEntries = CachingList.create(
                         RAFList.create((RandomAccessFile)raf, index.dict.htmlEntryIndexSerializer,
-                                ((RandomAccessFile)raf).getFilePointer(), index.dict.dictFileVersion), 1);
+                                ((RandomAccessFile)raf).getFilePointer(), index.dict.dictFileVersion,
+                                index.dict.dictInfo + " htmlEntries: "), 1);
             } else {
                 this.htmlEntries = Collections.emptyList();
             }
@@ -291,7 +299,7 @@ public final class Index implements RAFSerializable<Index> {
         int start = 0;
         int end = sortedIndexEntries.size();
 
-        final Collator sortCollator = sortLanguage.getCollator();
+        final Comparator sortCollator = sortLanguage.getCollator();
         while (start < end) {
             final int mid = (start + end) / 2;
             if (interrupted.get()) {
@@ -299,7 +307,9 @@ public final class Index implements RAFSerializable<Index> {
             }
             final IndexEntry midEntry = sortedIndexEntries.get(mid);
 
-            final int comp = sortCollator.compare(token, midEntry.normalizedToken());
+            int comp = NormalizeComparator.compareWithoutDash(token, midEntry.normalizedToken(), sortCollator, dict.dictFileVersion);
+            if (comp == 0)
+                comp = sortCollator.compare(token, midEntry.normalizedToken());
             if (comp == 0) {
                 final int result = windBackCase(token, mid, interrupted);
                 return result;
@@ -337,7 +347,7 @@ public final class Index implements RAFSerializable<Index> {
 
     private static final int MAX_SEARCH_ROWS = 1000;
 
-    private final Map<String, Integer> prefixToNumRows = new LinkedHashMap<String, Integer>();
+    private final Map<String, Integer> prefixToNumRows = new HashMap<String, Integer>();
 
     private synchronized final int getUpperBoundOnRowsStartingWith(final String normalizedPrefix,
             final int maxRows, final AtomicBoolean interrupted) {
@@ -372,7 +382,7 @@ public final class Index implements RAFSerializable<Index> {
         final long startMills = System.currentTimeMillis();
         final List<RowBase> result = new ArrayList<RowBase>();
 
-        final Set<String> normalizedNonStoplist = new LinkedHashSet<String>();
+        final Set<String> normalizedNonStoplist = new HashSet<String>();
 
         String bestPrefix = null;
         int leastRows = Integer.MAX_VALUE;