Run automated code cleanup.

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

diff --git a/src/com/hughes/android/dictionary/engine/Dictionary.java b/src/com/hughes/android/dictionary/engine/Dictionary.java
index 57ae6e73cd5f6c41ed392fa7d2f050eaa4b76251..0eb8007f07f9307fe0f44306e980d3f4f546d57b 100644 (file)
--- a/src/com/hughes/android/dictionary/engine/Dictionary.java
+++ b/src/com/hughes/android/dictionary/engine/Dictionary.java
@@ -22,11 +22,14 @@ import com.hughes.util.raf.RAFListSerializer;
 import com.hughes.util.raf.RAFSerializable;
 
 import java.io.DataInput;
+import java.io.DataInputStream;
 import java.io.DataOutput;
 import java.io.File;
 import java.io.IOException;
 import java.io.PrintStream;
 import java.io.RandomAccessFile;
+import java.nio.channels.Channels;
+import java.nio.channels.FileChannel;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -45,6 +48,7 @@ public class Dictionary implements RAFSerializable<Dictionary> {
     public final List<PairEntry> pairEntries;
     public final List<TextEntry> textEntries;
     public final List<HtmlEntry> htmlEntries;
+    public final List<byte[]> htmlData;
     public final List<EntrySource> sources;
     public final List<Index> indices;
 
@@ -60,11 +64,13 @@ public class Dictionary implements RAFSerializable<Dictionary> {
         pairEntries = new ArrayList<PairEntry>();
         textEntries = new ArrayList<TextEntry>();
         htmlEntries = new ArrayList<HtmlEntry>();
+        htmlData = null;
         sources = new ArrayList<EntrySource>();
         indices = new ArrayList<Index>();
     }
 
-    public Dictionary(final RandomAccessFile raf) throws IOException {
+    public Dictionary(final FileChannel ch) throws IOException {
+        DataInput raf = new DataInputStream(Channels.newInputStream(ch));
         dictFileVersion = raf.readInt();
         if (dictFileVersion < 0 || dictFileVersion > CURRENT_DICT_VERSION) {
             throw new IOException("Invalid dictionary version: " + dictFileVersion);
@@ -75,29 +81,33 @@ public class Dictionary implements RAFSerializable<Dictionary> {
         // 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);
+            final RAFList<EntrySource> rafSources = RAFList.create(ch, new EntrySource.Serializer(
+                    this), ch.position(), dictFileVersion, dictInfo + " sources: ");
             sources = new ArrayList<EntrySource>(rafSources);
-            raf.seek(rafSources.getEndOffset());
+            ch.position(rafSources.getEndOffset());
 
             pairEntries = CachingList.create(
-                    RAFList.create(raf, new PairEntry.Serializer(this), raf.getFilePointer(), dictFileVersion, dictFileVersion >= 7 ? 64 : 1, dictFileVersion >= 7),
-                    CACHE_SIZE);
+                              RAFList.create(ch, new PairEntry.Serializer(this), ch.position(), dictFileVersion, dictInfo + " pairs: "),
+                              CACHE_SIZE, false);
             textEntries = CachingList.create(
-                    RAFList.create(raf, new TextEntry.Serializer(this), raf.getFilePointer(), dictFileVersion),
-                    CACHE_SIZE);
+                              RAFList.create(ch, new TextEntry.Serializer(this), ch.position(), 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(ch, new HtmlEntry.Serializer(this, ch), ch.position(), dictFileVersion, dictInfo + " html: "),
+                                  CACHE_SIZE, false);
             } else {
                 htmlEntries = Collections.emptyList();
             }
-            indices = CachingList.createFullyCached(RAFList.create(raf, indexSerializer,
-                    raf.getFilePointer(), dictFileVersion));
+            if (dictFileVersion >= 7) {
+                htmlData = RAFList.create(ch, new HtmlEntry.DataDeserializer(), ch.position(), dictFileVersion, dictInfo + " html: ");
+            } else {
+                htmlData = null;
+            }
+            indices = CachingList.createFullyCached(RAFList.create(ch, new IndexSerializer(ch),
+                                                    ch.position(), dictFileVersion, dictInfo + " index: "));
         } catch (RuntimeException e) {
-            final IOException ioe = new IOException("RuntimeException loading dictionary");
-            ioe.initCause(e);
+            final IOException ioe = new IOException("RuntimeException loading dictionary", e);
             throw ioe;
         }
         final String end = raf.readUTF();
@@ -118,32 +128,39 @@ public class Dictionary implements RAFSerializable<Dictionary> {
         RAFList.write(raf, pairEntries, new PairEntry.Serializer(this), 64, true);
         System.out.println("text start: " + raf.getFilePointer());
         RAFList.write(raf, textEntries, new TextEntry.Serializer(this));
-        System.out.println("html start: " + raf.getFilePointer());
-        RAFList.write(raf, htmlEntries, new HtmlEntry.Serializer(this));
+        System.out.println("html index start: " + raf.getFilePointer());
+        RAFList.write(raf, htmlEntries, new HtmlEntry.Serializer(this, null), 64, true);
+        System.out.println("html data start: " + raf.getFilePointer());
+        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(null));
         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> {
+        private final FileChannel ch;
+
+        public IndexSerializer(FileChannel ch) {
+            this.ch = ch;
+        }
+
         @Override
         public Index read(DataInput raf, final int readIndex) throws IOException {
-            return new Index(Dictionary.this, raf);
+            return new Index(Dictionary.this, ch, 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 {
-            if (t.index() == -1)
-                throw new IndexOutOfBoundsException();
-            raf.writeInt(t.index());
+        public void write(DataOutput raf, HtmlEntry t) {
+            assert false;
         }
 
         @Override
@@ -179,14 +196,17 @@ public class Dictionary implements RAFSerializable<Dictionary> {
         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) {
-            return null;
+            final DictionaryInfo dictionaryInfo = new DictionaryInfo();
+            dictionaryInfo.uncompressedFilename = file.getName();
+            dictionaryInfo.uncompressedBytes = file.length();
+            return dictionaryInfo;
         } finally {
             if (raf != null) {
                 try {