Merge pull request #4 from WorksApplications/add-traverse

Add traverse()

Author: takaoka-k-wap

pom.xml

@@ -3,7 +3,7 @@
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.worksap.nlp</groupId>
   <artifactId>jdartsclone</artifactId>
-  <version>1.0.2-SNAPSHOT</version>
+  <version>1.1.0-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>Darts-clone</name>
 

src/main/java/com/worksap/nlp/dartsclone/DoubleArray.java

@@ -39,6 +39,27 @@
  */
 public class DoubleArray {
 
+    /**
+     * The result of a traverse operation.
+     *
+     * This class contains the result of a traverse, the position of the key,
+     * and the index of the node after the traverse.
+     */
+    public static class TraverseResult {
+        /** The result of a traverse */
+        public int result;
+        /** the position of the key after a traverse */
+        public int offset;
+        /** the node after a traverse */
+        public int nodePosition;
+
+        TraverseResult(int result, int offset, int nodePosition) {
+            this.result = result;
+            this.offset = offset;
+            this.nodePosition = nodePosition;
+        }
+    }
+
     private IntBuffer array;
     private ByteBuffer buffer;
     private int size;           // number of elements
@@ -235,6 +256,45 @@ public Iterator<int[]> commonPrefixSearch(byte[] key, int offset) {
         return new Itr(key, offset);
     }
 
+    /**
+     * Returns the value to which the specified key is mapped by
+     * traversing the trie from the specified node.
+     *
+     * If {@code node} is 0, starts traversing from the root node.
+     *
+     * If {@code offset} is not 0, the key is evaluated as the sub array
+     * removed the first {@code offset} bytes.
+     *
+     * Returns -1 as the value if a traverse is failed at the end of the key,
+     * or -2 at a middle of the key.
+     *
+     * @param key the key whose associated value is to be returned
+     * @param offset the offset of the key
+     * @param nodePosition the node to start a traverse
+     * @return the value to which the specified key is mapped,
+     *         the offset of the key, and the node after the traverse
+     */
+    public TraverseResult traverse(byte[] key, int offset, int nodePosition) {
+        int nodePos = nodePosition;
+        int id = nodePos;
+        int unit = array.get(id);
+
+        for (int i = offset; i < key.length; i++) {
+            byte k = key[i];
+            id ^= offset(unit) ^ Byte.toUnsignedInt(k);
+            unit = array.get(id);
+            if (label(unit) != Byte.toUnsignedInt(k)) {
+                return new TraverseResult(-2, i, nodePos);
+            }
+            nodePos = id;
+        }
+        if (!hasLeaf(unit)) {
+            return new TraverseResult(-1, key.length, nodePos);
+        }
+        unit = array.get(nodePos ^ offset(unit));
+        return new TraverseResult(value(unit), key.length, nodePos);
+    }
+
     private class Itr implements Iterator<int[]> {
         private final byte[] key;
         private int offset;

src/test/java/com/worksap/nlp/dartsclone/TraverseTest.java

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2019 Works Applications Co., Ltd.
+ *
+ * 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.worksap.nlp.dartsclone;
+
+import java.nio.charset.StandardCharsets;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+public class TraverseTest {
+
+    DoubleArray dic;
+
+    static final byte[] A = "a".getBytes(StandardCharsets.UTF_8);
+    static final byte[] AB = "ab".getBytes(StandardCharsets.UTF_8);
+    static final byte[] AC = "ac".getBytes(StandardCharsets.UTF_8);
+    static final byte[] B = "b".getBytes(StandardCharsets.UTF_8);
+    static final byte[] C = "c".getBytes(StandardCharsets.UTF_8);
+    static final byte[] CD = "cd".getBytes(StandardCharsets.UTF_8);
+
+    @Before
+    public void setUp() {
+        byte[][] keys = new byte[][] { A, AB, CD };
+        dic = new DoubleArray();
+        dic.build(keys, null, null);
+    }
+
+    @Test
+    public void traverse() {
+        DoubleArray.TraverseResult r = dic.traverse(A, 0, 0);
+        assertTrue(r.result >= 0);
+        assertEquals(1, r.offset);
+        DoubleArray.TraverseResult r2 = dic.traverse(B, 0, r.nodePosition);
+        assertTrue(r2.result >= 0);
+        assertEquals(1, r2.offset);
+        DoubleArray.TraverseResult r3 = dic.traverse(AB, 1, r.nodePosition);
+        assertTrue(r3.result >= 0);
+        assertEquals(2, r3.offset);
+    }
+
+    @Test
+    public void traverseNotMatchWithEnd() {
+        DoubleArray.TraverseResult r = dic.traverse(C, 0, 0);
+        assertEquals(-1, r.result);
+        assertEquals(1, r.offset);
+        DoubleArray.TraverseResult r2 = dic.traverse(CD, 1, r.nodePosition);
+        assertTrue(r2.result >= 0);
+        assertEquals(2, r2.offset);
+    }
+
+    @Test
+    public void traverseNotMatchMiddle() {
+        DoubleArray.TraverseResult r = dic.traverse(AC, 0, 0);
+        assertEquals(-2, r.result);
+        assertEquals(1, r.offset);
+        DoubleArray.TraverseResult r2 = dic.traverse(B, 0, r.nodePosition);
+        assertTrue(r2.result >= 0);
+        assertEquals(1, r2.offset);
+    }
+}