1 files changed, 123 insertions, 0 deletions
diff --git a/java/src/com/android/inputmethod/latin/makedict/SparseTableContentUpdater.java b/java/src/com/android/inputmethod/latin/makedict/SparseTableContentUpdater.java
new file mode 100644
index 000000000..4518f21b9
--- /dev/null
+++ b/java/src/com/android/inputmethod/latin/makedict/SparseTableContentUpdater.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.inputmethod.latin.makedict;
+
+import com.android.inputmethod.latin.makedict.DictDecoder.DictionaryBufferFactory;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+
+/**
+ * An auxiliary class for updating data associated with SparseTable.
+ */
+public class SparseTableContentUpdater extends SparseTableContentReader {
+    protected OutputStream mLookupTableOutStream;
+    protected OutputStream[] mAddressTableOutStreams;
+    protected OutputStream[] mContentOutStreams;
+
+    public SparseTableContentUpdater(final String name, final int blockSize,
+            final File baseDir, final String[] contentFilenames, final String[] contentIds,
+            final DictionaryBufferFactory factory) {
+        super(name, blockSize, baseDir, contentFilenames, contentIds, factory);
+        mAddressTableOutStreams = new OutputStream[mContentCount];
+        mContentOutStreams = new OutputStream[mContentCount];
+    }
+
+    protected void openStreamsAndBuffers() throws IOException {
+        openBuffers();
+        mLookupTableOutStream = new FileOutputStream(mLookupTableFile, true /* append */);
+        for (int i = 0; i < mContentCount; ++i) {
+            mAddressTableOutStreams[i] = new FileOutputStream(mAddressTableFiles[i],
+                    true /* append */);
+            mContentOutStreams[i] = new FileOutputStream(mContentFiles[i], true /* append */);
+        }
+    }
+
+    /**
+     * Set the contentIndex-th elements of contentId-th table.
+     *
+     * @param contentId the id of the content table.
+     * @param contentIndex the index where to set the valie.
+     * @param value the value to set.
+     */
+    protected void setContentValue(final int contentId, final int contentIndex, final int value)
+            throws IOException {
+        if ((contentIndex / mBlockSize) * SparseTable.SIZE_OF_INT_IN_BYTES
+                >= mLookupTableBuffer.limit()) {
+            // Need to extend the lookup table
+            final int currentSize = mLookupTableBuffer.limit()
+                    / SparseTable.SIZE_OF_INT_IN_BYTES;
+            final int target = contentIndex / mBlockSize + 1;
+            for (int i = currentSize; i < target; ++i) {
+                BinaryDictEncoderUtils.writeUIntToStream(mLookupTableOutStream,
+                        SparseTable.NOT_EXIST, SparseTable.SIZE_OF_INT_IN_BYTES);
+            }
+            // We need to reopen the byte buffer of the lookup table because a MappedByteBuffer in
+            // Java isn't expanded automatically when the underlying file is expanded.
+            reopenLookupTable();
+        }
+
+        mLookupTableBuffer.position((contentIndex / mBlockSize) * SparseTable.SIZE_OF_INT_IN_BYTES);
+        int posInAddressTable = mLookupTableBuffer.readInt();
+        if (posInAddressTable == SparseTable.NOT_EXIST) {
+            // Need to extend the address table
+            mLookupTableBuffer.position(mLookupTableBuffer.position()
+                    - SparseTable.SIZE_OF_INT_IN_BYTES);
+            posInAddressTable = mAddressTableBuffers[0].limit() / mBlockSize;
+            BinaryDictEncoderUtils.writeUIntToDictBuffer(mLookupTableBuffer,
+                    posInAddressTable, SparseTable.SIZE_OF_INT_IN_BYTES);
+            for (int i = 0; i < mContentCount; ++i) {
+                for (int j = 0; j < mBlockSize; ++j) {
+                    BinaryDictEncoderUtils.writeUIntToStream(mAddressTableOutStreams[i],
+                            SparseTable.NOT_EXIST, SparseTable.SIZE_OF_INT_IN_BYTES);
+                }
+            }
+            // We need to reopen the byte buffers of the address tables because a MappedByteBuffer
+            // in Java isn't expanded automatically when the underlying file is expanded.
+            reopenAddressTables();
+        }
+        posInAddressTable += (contentIndex % mBlockSize) * SparseTable.SIZE_OF_INT_IN_BYTES;
+
+        mAddressTableBuffers[contentId].position(posInAddressTable);
+        BinaryDictEncoderUtils.writeUIntToDictBuffer(mAddressTableBuffers[contentId],
+                value, SparseTable.SIZE_OF_INT_IN_BYTES);
+    }
+
+    private void reopenLookupTable() throws IOException {
+        mLookupTableOutStream.flush();
+        mLookupTableBuffer = mFactory.getDictionaryBuffer(mLookupTableFile);
+    }
+
+    private void reopenAddressTables() throws IOException {
+        for (int i = 0; i < mContentCount; ++i) {
+            mAddressTableOutStreams[i].flush();
+            mAddressTableBuffers[i] = mFactory.getDictionaryBuffer(mAddressTableFiles[i]);
+        }
+    }
+
+    protected void close() throws IOException {
+        mLookupTableOutStream.close();
+        for (final OutputStream stream : mAddressTableOutStreams) {
+            stream.close();
+        }
+        for (final OutputStream stream : mContentOutStreams) {
+            stream.close();
+        }
+    }
+}