svn commit: r1669520 - /commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/text/translate/LookupTranslator.java

[br...@apache.org]

Author: britter
Date: Fri Mar 27 08:03:41 2015
New Revision: 1669520

URL: http://svn.apache.org/r1669520
Log:
Further optimization of LANG-935:
- Avoid toString of the replacement sequence by doing it once.
- Avoid calculating the maximum when not needed.
- Fixup comment for greedy algorithm

Thanks to Fabian Lange.


Modified:
    commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/text/translate/LookupTranslator.java

Modified: commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/text/translate/LookupTranslator.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/text/translate/LookupTranslator.java?rev=1669520&r1=1669519&r2=1669520&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/text/translate/LookupTranslator.java (original)
+++ commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/text/translate/LookupTranslator.java Fri Mar 27 08:03:41 2015
@@ -29,7 +29,7 @@ import java.util.HashSet;
  */
 public class LookupTranslator extends CharSequenceTranslator {
 
-    private final HashMap<String, CharSequence> lookupMap;
+    private final HashMap<String, String> lookupMap;
     private final HashSet<Character> prefixSet;
     private final int shortest;
     private final int longest;
@@ -37,21 +37,20 @@ public class LookupTranslator extends Ch
     /**
      * Define the lookup table to be used in translation
      *
-     * Note that, as of Lang 3.1, the key to the lookup table is converted to a 
-     * java.lang.String, while the value remains as a java.lang.CharSequence. 
-     * This is because we need the key to support hashCode and equals(Object), 
-     * allowing it to be the key for a HashMap. See LANG-882.
+     * Note that, as of Lang 3.1, the key to the lookup table is converted to a
+     * java.lang.String. This is because we need the key to support hashCode and
+     * equals(Object), allowing it to be the key for a HashMap. See LANG-882.
      *
      * @param lookup CharSequence[][] table of size [*][2]
      */
     public LookupTranslator(final CharSequence[]... lookup) {
-        lookupMap = new HashMap<String, CharSequence>();
+        lookupMap = new HashMap<String, String>();
         prefixSet = new HashSet<Character>();
         int _shortest = Integer.MAX_VALUE;
         int _longest = 0;
         if (lookup != null) {
             for (final CharSequence[] seq : lookup) {
-                this.lookupMap.put(seq[0].toString(), seq[1]);
+                this.lookupMap.put(seq[0].toString(), seq[1].toString());
                 this.prefixSet.add(seq[0].charAt(0));
                 final int sz = seq[0].length();
                 if (sz < _shortest) {
@@ -71,24 +70,21 @@ public class LookupTranslator extends Ch
      */
     @Override
     public int translate(final CharSequence input, final int index, final Writer out) throws IOException {
-        int max = longest;
-        if (index + longest > input.length()) {
-            max = input.length() - index;
-        }
-
-        if (!prefixSet.contains(input.charAt(index))) {
-            // no translation exists for the input at position index
-            return 0;
-        }
-
-        // descend so as to get a greedy algorithm
-        for (int i = max; i >= shortest; i--) {
-            final CharSequence subSeq = input.subSequence(index, index + i);
-            final CharSequence result = lookupMap.get(subSeq.toString());
-
-            if (result != null) {
-                out.write(result.toString());
-                return i;
+        // check if translation exists for the input at position index
+        if (prefixSet.contains(input.charAt(index))) {
+            int max = longest;
+            if (index + longest > input.length()) {
+                max = input.length() - index;
+            }
+            // implement greedy algorithm by trying maximum match first
+            for (int i = max; i >= shortest; i--) {
+                final CharSequence subSeq = input.subSequence(index, index + i);
+                final String result = lookupMap.get(subSeq.toString());
+
+                if (result != null) {
+                    out.write(result);
+                    return i;
+                }
             }
         }
         return 0;