Cache#pass - new function

Strings#contains - support for CharSequence
Strings#indexOf - version for CharSequence

AnsiPattern - better performance for string-matcher

pom.xml

@@ -5,7 +5,7 @@
 
     <groupId>net.ranides</groupId>
     <artifactId>assira</artifactId>
-    <version>0.67.1</version>
+    <version>0.67.2</version>
     <packaging>jar</packaging>
 
     <name>assira</name>

src/main/java/net/ranides/assira/collection/map/Cache.java

@@ -107,6 +107,20 @@ public class Cache<K,V> extends AbstractMap<K,V> {
         }
         return result;
     }
+    
+    /**
+     * Wstawia wartość do cache'u i zwraca ją jako wynik. Jeśli w mapie
+     * istniała już jakaś wartość, to ją zastępuje.
+     * @param key
+     * @param value
+     * @return 
+     * @since 0.67.2
+     */
+    public synchronized V pass(K key, V value) {
+        release();
+        map.put(key, new ReferenceEntry<>(key, value, queue));
+        return value;
+    }
 
     @Override
     public synchronized V put(K key, V value) {

src/main/java/net/ranides/assira/text/Strings.java

@@ -100,12 +100,12 @@ public final class Strings {
         }
     }
 
-    public static boolean contains(String text, char value) {
-        return text!=null && text.indexOf(value) != -1;
+    public static boolean contains(CharSequence text, char value) {
+        return -1 != indexOf(text, value, 0);
     }
 
-    public static boolean contains(String text, CharSequence value) {
-        return text!=null && text.contains(value);
+    public static boolean contains(CharSequence text, CharSequence value) {
+        return -1 != indexOf(text, value, 0);
     }
 
     public static int length(String value) {
@@ -126,6 +126,65 @@ public final class Strings {
         return new ArrayWrapper(data);
     }
     
+    public static int indexOf(CharSequence text, char value, int offset) {    
+        if(null == text) {
+            return -1;
+        }
+        for(int i=0,n=text.length(); i<n; i++) {
+            if(value == text.charAt(i)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    
+    @SuppressWarnings({"PMD", "empty-statement"})
+    public static int indexOf(CharSequence text, CharSequence value, int offset) {
+        // implementation copied from java.lang.String
+        // we don't want to change tricky details
+        
+        if(null == text || null == value) {
+            return -1;
+        }
+        
+        int sourceCount = text.length();
+        int targetCount = value.length();
+        
+        if (offset >= sourceCount) {
+            return (targetCount == 0 ? sourceCount : -1);
+        }
+        if (offset < 0) {
+            offset = 0;
+        }
+        if (targetCount == 0) {
+            return offset;
+        }
+
+        char first = value.charAt(0);
+        int max = (sourceCount - targetCount);
+
+        for (int i = offset; i <= max; i++) {
+            /* Look for first character. */
+            if (text.charAt(i) != first) {
+                while (++i <= max && text.charAt(i) != first);
+            }
+
+            /* Found first character, now look at the rest of v2 */
+            if (i <= max) {
+                int j = i + 1;
+                int end = j + targetCount - 1;
+                for (int k = 1; j < end && text.charAt(j)
+                        == value.charAt(k); j++, k++);
+
+                if (j == end) {
+                    /* Found whole string. */
+                    return i;
+                }
+            }
+        }
+        return -1;
+    }
+    
     /**
      * Cholernie przekombinowana metoda, która dodaje do javy pseudo-support dla
      * psuedo-raw-string-literals. Używa się jej prosto: <code>Strings.raw(/&#42raw text here;&#42;/)</code>

src/main/java/net/ranides/assira/text/format/AnsiPattern.java

@@ -10,6 +10,7 @@ import java.util.Iterator;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import net.ranides.assira.collection.VirtualIterator;
+import net.ranides.assira.text.Strings;
 
 /**
  *
@@ -64,24 +65,22 @@ public abstract class AnsiPattern {
     
     private static class SIterator extends VirtualIterator<AnsiMatch> {
 
-        private final AnsiCharSequence ainput; 
-        private final String sinput; 
+        private final AnsiCharSequence input; 
         private final String pattern;
         private int offset = -1;
 
         public SIterator(AnsiCharSequence input, String pattern) {
-            this.ainput = input;
-            this.sinput = input.toString();
+            this.input = input;
             this.pattern = pattern;
         }
         
         @Override
         public AnsiMatch get() {
-            offset = sinput.indexOf(pattern, offset+1);
+            offset = Strings.indexOf(input, pattern, offset+1);
             if(-1 == offset) {
                 return null;
             } else {
-                return new AnsiMatch(ainput, offset, offset+pattern.length());
+                return new AnsiMatch(input, offset, offset+pattern.length());
             }
         }
 

src/test/java/net/ranides/assira/text/StringsTest.java

@@ -13,7 +13,16 @@ import static org.junit.Assert.*;
  *
  * @author Ranides Atterwim <ranides@gmail.com>
  */
+@SuppressWarnings("PMD")
 public class StringsTest {
+    
+    @Test
+    public void testIndexOf() {
+        assertEquals(4, Strings.indexOf("hello world", "o", 0));
+        assertEquals(4, Strings.indexOf("hello world", "o", 4));
+        assertEquals(7, Strings.indexOf("hello world", "o", 5));
+        assertEquals(7, Strings.indexOf("hello world", "or", 0));
+    }
 
     @Test
     public void testRaw() {