Changeset 5156

Timestamp:

2003-08-18T13:58:40+12:00 (21 years ago)

Author:

jmt12

Message:

Fix 203B096

File:

• trunk/gli/src/org/greenstone/gatherer/gui/metaaudit/Autofilter.java (modified) (8 diffs)

trunk/gli/src/org/greenstone/gatherer/gui/metaaudit/Autofilter.java

@@ -6 +6 @@
  * University of Waikato, New Zealand.
  *
- * <BR><BR>
- *
  * Author: John Thompson, Greenstone Digital Library, University of Waikato
  *
- * <BR><BR>
- *
  * Copyright (C) 1999 New Zealand Digital Library Project
- *
- * <BR><BR>
  *
  * This program is free software; you can redistribute it and/or modify
@@ -21 +15 @@
  * (at your option) any later version.
  *
- * <BR><BR>
- *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- *
- * <BR><BR>
  *
  * You should have received a copy of the GNU General Public License
@@ -35 +25 @@
  *########################################################################
  */
-
- 
-
-
-
-
-/* GPL_HEADER */
 package org.greenstone.gatherer.gui.metaaudit;
 /**************************************************************************************
@@ -50 +33 @@
  * Written:        /05/02
  * Revised:      22/08/02 Revamped, Optimized and Commented.
+ *               13-08-03 Extended matching functionality to correctly handle the wildcard character
  **************************************************************************************/
 
 import java.util.ArrayList;
+import org.greenstone.gatherer.util.StaticStrings;
 /** An Autofilter object stores the filters set on a single column, and provides a method for determining if a certain value passes the filter.
  * @author John Thompson
@@ -58 +43 @@
  */
 public class Autofilter {
+
+    static public void main(String[] args) {
+    if(args.length != 2) {
+        System.err.println("Usage: java Autofilter <string> <pattern>");
+    }
+    else {
+        switch(compareToPattern(args[0], args[1])) {
+        case LESS_THAN:
+        System.err.print(args[0] + " is less than");
+        break;
+        case GREATER_THAN:
+        System.err.print(args[0] + " is greater than");
+        break;
+        case EQUAL:
+        System.err.print(args[0] + " is equal to");
+        break;
+        default:
+        System.err.print(args[0] + " is something to");
+        }
+        System.err.println(" " + args[1]);
+    }
+    }
+
+    /** A String comparison which also recognises the WildCard character. The basic idea is that '*' matches zero or more of any characters, and if we limited patterns to be like "a*" then as soon as we hit the star we could return a match. The problem is that we want patterns like "b*y" which would match "boy" but not "bee" nor "bus" (but should return less than or greater than for each of these respectively). Thus our testing has to become non-deterministic so the matches are conducted like so: 
+     * Given p = [ b * y ]
+     * Test  s = [ b e e ]  Result: p0=s0,{(p2>s1=>ERROR),(p1=s1,{(p1>s2=>ERROR),(p2>s2=>LESS_THAN)})} => LESS_THAN
+     * Test  s = [ b o y ]  Result: p0=s0,{(p2>s1=>ERROR),(p1=s1,{(p1>s2=>ERROR),(p2=s2=>EQUAL)})} => EQUAL
+     * Test  s = [ b u s ]  Result: p0=s0,{(p2>s1=>ERROR),(p1=s1,{(p1>s2=>ERROR),(p2<s2=>GREATER_THAN)})} => GREATER_THAN
+     * where the two () phrases within a {} represent two different 'threads' of processing. Errors are generated when one string runs out of characters before the other. Only non-error results are propogated. I've decided to implement this non-deterministic matching as a recursive function call.
+     * If you analyse it you can see there are three possible actions when a '*' is detected.
+     * 1. * is an empty string, ignore it in pattern and try to compare the next character in p with the current character in s. This case only occurs if there are more characters in p (otherwise apple would be greater than a*)
+     * 2. * matches exactly the current character in s, try to match the next character in p with the next character in s
+     * 3. * matches some string of characters including the current character in s, try to match '*' against the next character in s
+     * @param  s the String being matched
+     * @param  p the Pattern to match it against
+     * @return -1 if s is less than p, 0 if they are equal, 1 if s is greater than p
+     */
+    static public int compareToPattern(String s, String p) {
+    if(p.indexOf(StaticStrings.STAR_CHAR) == -1) {
+        return compareToPattern(s, p, 0, 0, false);
+    }
+    else {
+        return compareToPattern(s, p, 0, 0, true);
+    }
+    }
+
+    static final private int LESS_THAN = -1;
+    static final private int EQUAL = 0;
+    static final private int GREATER_THAN = 1;
+    static final private int ERROR = 42;
+
+    static private int compareToPattern(String s, String p, int s_index, int p_index, boolean wildcard_matching) {
+    // Lets do the simple cases first.
+    // Both out of characters at the same time
+    if(s_index >= s.length() && p_index >= p.length()) {
+        ///ystem.err.println("Both out of characters. Equal.");
+        return EQUAL;
+    }
+    // s out of characters first
+    if(s_index >= s.length()) {
+        // Not allowed to run out if matching wildcard
+        if(wildcard_matching) {
+        return ERROR;
+        }
+        // Remember that wildcard matches the empty string too, so as long as there are only '*' characters left in the pattern we can say they are equal as well.
+        else {
+        while(p_index < p.length()) {
+            if(p.charAt(p_index) == StaticStrings.STAR_CHAR) {
+            p_index++;
+            }
+            else {
+            ///ystem.err.println("S out of characters. Less Than.");
+            return LESS_THAN;
+            }
+        }
+        // We've run out of pattern and it only contained '*' so we're still equal
+        ///ystem.err.println("Both out of characters. Equal.");
+        return EQUAL;
+        }
+    }
+    // p out of characters first
+    if(p_index >= p.length()) {
+        // Not allowed to run out if matching wildcard
+        if(wildcard_matching) {
+        return ERROR;
+        }
+        // so it is greater than
+        else {
+        ///ystem.err.println("P out of characters. Greater Than.");
+        return GREATER_THAN;
+        }
+    }
+    char s_char = s.charAt(s_index);
+    char p_char = p.charAt(p_index);
+    ///ystem.err.println("Comparing " + s_char + " against pattern character " + p_char);
+    // Equivelent characters
+    // Now the tricky-dicky bit - WildCard matching.
+    if(p_char == StaticStrings.STAR_CHAR) {
+        int result;
+        // Case 1
+        ///ystem.err.println("WildCard Case 1");
+        if(p_index + 1 < p.length()) {
+        if((result = compareToPattern(s, p, s_index, p_index + 1, wildcard_matching)) != ERROR) {
+            return result;
+        }
+        }
+        // Case 2
+        ///ystem.err.println("WildCard Case 2");
+        if((result = compareToPattern(s, p, s_index + 1, p_index + 1, wildcard_matching)) != ERROR) {
+        return result;
+        } 
+        // Case 3
+        ///ystem.err.println("WildCard Case 3");
+        if((result = compareToPattern(s, p, s_index + 1, p_index, wildcard_matching)) != ERROR) {
+        return result;
+        }
+    }
+    if(s_char == p_char) {
+        return compareToPattern(s, p, s_index + 1, p_index + 1, wildcard_matching);
+    }
+    // A preceeding character
+    if(s_char < p_char) {
+        ///ystem.err.println("s char is less than p char");
+        if(wildcard_matching) {
+        ///ystem.err.println("Because we are wildcard matching we still have to match the rest of s incase of errors.");
+        if(compareToPattern(s, p, s_index + 1, p_index + 1, wildcard_matching) != ERROR) {
+            ///ystem.err.println("No error. Less than.");
+            return LESS_THAN;
+        }
+        else {
+            ///ystem.err.println("Error detected.");
+            return ERROR;
+        }
+        }
+        else {
+        ///ystem.err.println("Less than.");
+        return LESS_THAN;
+        }
+    }
+    // A succeeding character
+    if(s_char > p_char) {
+        ///ystem.err.println("s char is greater than p char");
+        if(wildcard_matching) {
+        ///ystem.err.println("Because we are wildcard matching we still have to match the rest of s incase of errors.");
+        if(compareToPattern(s, p, s_index + 1, p_index + 1, wildcard_matching) != ERROR) {
+            ///ystem.err.println("No error. Greater than.");
+            return GREATER_THAN;
+        }
+        else {
+            ///ystem.err.println("Error detected.");
+            return ERROR;
+        }
+        }
+        else {
+        ///ystem.err.println("Greater than.");
+        return GREATER_THAN;
+        }
+    }
+    // Oh-No. Well, we'll just assume that string is less than pattern
+    return LESS_THAN;
+    }
+
     /** <i>true</i> if the filter should be applied, <i>false</i> to indicate the filter is turned off. */
     public boolean active;
@@ -169 +316 @@
     }
     else {
-                // For each value in the list...
+        // For each value in the list...
         for(int i = 0; i < values.size(); i++) {
         boolean pass;
@@ -180 +327 @@
             source = values.get(i).toString().toLowerCase();
         }
+        System.err.println("Testing " + source + " against pattern " + target);
         // Perform the match, based on the selected method.
         switch(method) {
         case 1: // !EQ
-            pass = !(source.equals(target));
+            pass = (compareToPattern(source, target) != 0);
             break;
         case 2: // <
-            pass = (source.compareTo(target) < 0);
+            pass = (compareToPattern(source, target) < 0);
             break;
         case 3: // <eq
-            pass = (source.compareTo(target) <= 0);
+            pass = (compareToPattern(source, target) <= 0);
             break;
         case 4: // >
-            pass = (source.compareTo(target) > 0);
+            pass = (compareToPattern(source, target) > 0);
             break;
         case 5: // >eq
-            pass = (source.compareTo(target) >= 0);
+            pass = (compareToPattern(source, target) >= 0);
             break;
         case 6: // ^
@@ -216 +364 @@
             break;
         default: // EQEQ
-            pass = source.equals(target);
+            pass = (compareToPattern(source, target) == 0);
             break;
         }