X-Git-Url: http://gitweb.fperrin.net/?a=blobdiff_plain;f=src%2Fcom%2Fhughes%2Fandroid%2Fdictionary%2Fengine%2FDictionary.java;h=5b209b037da3095ebc398683331746062b237f92;hb=9cab1701d42d237791c816e8593b36abf515973a;hp=1a57d89c44942094e996613e1ee62bdca6030ec3;hpb=0c346cf361e8af0e69cf3f0214d017e6660fea26;p=Dictionary.git

diff --git a/src/com/hughes/android/dictionary/engine/Dictionary.java b/src/com/hughes/android/dictionary/engine/Dictionary.java
index 1a57d89..5b209b0 100644
--- a/src/com/hughes/android/dictionary/engine/Dictionary.java
+++ b/src/com/hughes/android/dictionary/engine/Dictionary.java
@@ -14,40 +14,44 @@
 
 package com.hughes.android.dictionary.engine;
 
-import com.hughes.android.dictionary.DictionaryInfo;
-import com.hughes.util.CachingList;
-import com.hughes.util.StringUtil;
-import com.hughes.util.raf.RAFList;
-import com.hughes.util.raf.RAFListSerializer;
-import com.hughes.util.raf.RAFSerializable;
-
 import java.io.DataInput;
 import java.io.DataOutput;
 import java.io.File;
 import java.io.IOException;
 import java.io.PrintStream;
 import java.io.RandomAccessFile;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-public class Dictionary implements RAFSerializable<Dictionary> {
+import com.hughes.android.dictionary.DictionaryInfo;
+import com.hughes.util.CachingList;
+import com.hughes.util.DataInputBuffer;
+import com.hughes.util.raf.RAFList;
+import com.hughes.util.raf.RAFListSerializer;
 
-    static final int CACHE_SIZE = 5000;
+public class Dictionary {
 
-    static final int CURRENT_DICT_VERSION = 7;
-    static final String END_OF_DICTIONARY = "END OF DICTIONARY";
+    private static final int CACHE_SIZE = 5000;
+
+    private static final int CURRENT_DICT_VERSION = 7;
+    private static final String END_OF_DICTIONARY = "END OF DICTIONARY";
 
     // persisted
     final int dictFileVersion;
-    final long creationMillis;
+    public final long creationMillis;
     public final String dictInfo;
     public final List<PairEntry> pairEntries;
     public final List<TextEntry> textEntries;
     public final List<HtmlEntry> htmlEntries;
-    public final List<byte[]> htmlData;
+    public final List<DataInputBuffer> htmlData;
     public final List<EntrySource> sources;
     public final List<Index> indices;
+    // Could be a local variable in constructor, but
+    // this way avoids a native-image VM bug.
+    private final MappedByteBuffer wholefile;
 
     /**
      * dictFileVersion 1 adds: <li>links to sources? dictFileVersion 2 adds: <li>
@@ -58,64 +62,65 @@ public class Dictionary implements RAFSerializable<Dictionary> {
         this.dictFileVersion = CURRENT_DICT_VERSION;
         this.creationMillis = System.currentTimeMillis();
         this.dictInfo = dictInfo;
-        pairEntries = new ArrayList<PairEntry>();
-        textEntries = new ArrayList<TextEntry>();
-        htmlEntries = new ArrayList<HtmlEntry>();
+        pairEntries = new ArrayList<>();
+        textEntries = new ArrayList<>();
+        htmlEntries = new ArrayList<>();
         htmlData = null;
-        sources = new ArrayList<EntrySource>();
-        indices = new ArrayList<Index>();
+        sources = new ArrayList<>();
+        indices = new ArrayList<>();
+        wholefile = null;
     }
 
-    public Dictionary(final RandomAccessFile raf) throws IOException {
-        dictFileVersion = raf.readInt();
+    public Dictionary(final FileChannel ch) throws IOException {
+        wholefile = ch.map(FileChannel.MapMode.READ_ONLY, 0, ch.size());
+        DataInputBuffer in = new DataInputBuffer(wholefile, 0);
+        dictFileVersion = in.readInt();
         if (dictFileVersion < 0 || dictFileVersion > CURRENT_DICT_VERSION) {
             throw new IOException("Invalid dictionary version: " + dictFileVersion);
         }
-        creationMillis = raf.readLong();
-        dictInfo = raf.readUTF();
+        creationMillis = in.readLong();
+        dictInfo = in.readUTF();
 
         // Load the sources, then seek past them, because reading them later
         // disrupts the offset.
         try {
-            final RAFList<EntrySource> rafSources = RAFList.create(raf, new EntrySource.Serializer(
-                    this), raf.getFilePointer(), dictFileVersion);
-            sources = new ArrayList<EntrySource>(rafSources);
-            raf.seek(rafSources.getEndOffset());
+            final RAFList<EntrySource> rafSources = RAFList.create(in, new EntrySource.Serializer(
+                    this), dictFileVersion, dictInfo + " sources: ");
+            sources = new ArrayList<>(rafSources);
+            ch.position(rafSources.getEndOffset());
 
             pairEntries = CachingList.create(
-                    RAFList.create(raf, new PairEntry.Serializer(this), raf.getFilePointer(), dictFileVersion),
-                    CACHE_SIZE);
+                              RAFList.create(in, new PairEntry.Serializer(this), dictFileVersion, dictInfo + " pairs: "),
+                              CACHE_SIZE, false);
             textEntries = CachingList.create(
-                    RAFList.create(raf, new TextEntry.Serializer(this), raf.getFilePointer(), dictFileVersion),
-                    CACHE_SIZE);
+                              RAFList.create(in, new TextEntry.Serializer(this), dictFileVersion, dictInfo + " text: "),
+                              CACHE_SIZE, true);
             if (dictFileVersion >= 5) {
                 htmlEntries = CachingList.create(
-                        RAFList.create(raf, new HtmlEntry.Serializer(this), raf.getFilePointer(), dictFileVersion),
-                        CACHE_SIZE);
+                                  RAFList.create(in, new HtmlEntry.Serializer(this), dictFileVersion, dictInfo + " html: "),
+                                  CACHE_SIZE, false);
             } else {
                 htmlEntries = Collections.emptyList();
             }
             if (dictFileVersion >= 7) {
-                htmlData = RAFList.create(raf, new HtmlEntry.DataDeserializer(), raf.getFilePointer(), dictFileVersion);
+                htmlData = RAFList.create(in, new HtmlEntry.DataDeserializer(), dictFileVersion, dictInfo + " html: ");
             } else {
                 htmlData = null;
             }
-            indices = CachingList.createFullyCached(RAFList.create(raf, indexSerializer,
-                    raf.getFilePointer(), dictFileVersion));
+            indices = CachingList.createFullyCached(RAFList.create(in, new IndexSerializer(),
+                                                    dictFileVersion, dictInfo + " index: "));
         } catch (RuntimeException e) {
-            final IOException ioe = new IOException("RuntimeException loading dictionary");
-            ioe.initCause(e);
-            throw ioe;
+            throw new IOException("RuntimeException loading dictionary", e);
         }
-        final String end = raf.readUTF();
+        final String end = in.readUTF();
         if (!end.equals(END_OF_DICTIONARY)) {
             throw new IOException("Dictionary seems corrupt: " + end);
         }
     }
 
-    @Override
     public void write(DataOutput out) throws IOException {
         RandomAccessFile raf = (RandomAccessFile)out;
+        if (dictFileVersion < 7) throw new RuntimeException("write function cannot write formats older than v7!");
         raf.writeInt(dictFileVersion);
         raf.writeLong(creationMillis);
         raf.writeUTF(dictInfo);
@@ -131,26 +136,26 @@ public class Dictionary implements RAFSerializable<Dictionary> {
         assert htmlData == null;
         RAFList.write(raf, htmlEntries, new HtmlEntry.DataSerializer(), 128, true);
         System.out.println("indices start: " + raf.getFilePointer());
-        RAFList.write(raf, indices, indexSerializer);
+        RAFList.write(raf, indices, new IndexSerializer());
         System.out.println("end: " + raf.getFilePointer());
         raf.writeUTF(END_OF_DICTIONARY);
     }
 
-    private final RAFListSerializer<Index> indexSerializer = new RAFListSerializer<Index>() {
+    private final class IndexSerializer implements RAFListSerializer<Index> {
         @Override
         public Index read(DataInput raf, final int readIndex) throws IOException {
-            return new Index(Dictionary.this, raf);
+            return new Index(Dictionary.this, (DataInputBuffer)raf);
         }
 
         @Override
         public void write(DataOutput raf, Index t) throws IOException {
             t.write(raf);
         }
-    };
+    }
 
     final RAFListSerializer<HtmlEntry> htmlEntryIndexSerializer = new RAFListSerializer<HtmlEntry>() {
         @Override
-        public void write(DataOutput raf, HtmlEntry t) throws IOException {
+        public void write(DataOutput raf, HtmlEntry t) {
             assert false;
         }
 
@@ -183,21 +188,30 @@ public class Dictionary implements RAFSerializable<Dictionary> {
         return result;
     }
 
+    // get DictionaryInfo for case when Dictionary cannot be opened
+    private static DictionaryInfo getErrorDictionaryInfo(final File file) {
+        final DictionaryInfo dictionaryInfo = new DictionaryInfo();
+        dictionaryInfo.uncompressedFilename = file.getName();
+        dictionaryInfo.uncompressedBytes = file.length();
+        return dictionaryInfo;
+    }
+
     public static DictionaryInfo getDictionaryInfo(final File file) {
         RandomAccessFile raf = null;
         try {
             raf = new RandomAccessFile(file, "r");
-            final Dictionary dict = new Dictionary(raf);
+            final Dictionary dict = new Dictionary(raf.getChannel());
             final DictionaryInfo dictionaryInfo = dict.getDictionaryInfo();
             dictionaryInfo.uncompressedFilename = file.getName();
             dictionaryInfo.uncompressedBytes = file.length();
             raf.close();
             return dictionaryInfo;
         } catch (IOException e) {
-            final DictionaryInfo dictionaryInfo = new DictionaryInfo();
-            dictionaryInfo.uncompressedFilename = file.getName();
-            dictionaryInfo.uncompressedBytes = file.length();
-            return dictionaryInfo;
+            return getErrorDictionaryInfo(file);
+        } catch (IllegalArgumentException e) {
+            // Most likely due to a Buffer.limit beyond size of file,
+            // do not crash just because of a truncated dictionary file
+            return getErrorDictionaryInfo(file);
         } finally {
             if (raf != null) {
                 try {