AbstractRegExpPredicate.java
01 /*
02  *  Constraint Predicate implementation
03  *
04  *  Copyright (c) 1995-2012, The University of Sheffield. See the file
05  *  COPYRIGHT.txt in the software or at http://gate.ac.uk/gate/COPYRIGHT.txt
06  *
07  *  This file is part of GATE (see http://gate.ac.uk/), and is free
08  *  software, licenced under the GNU Library General Public License,
09  *  Version 2, June 1991 (in the distribution as file licence.html,
10  *  and also available at http://gate.ac.uk/gate/licence.html).
11  *
12  *  Eric Sword, 03/09/08
13  *
14  *  $Id$
15  */
16 package gate.jape.constraint;
17 
18 import gate.AnnotationSet;
19 import gate.jape.JapeException;
20 
21 import java.util.regex.Matcher;
22 import java.util.regex.Pattern;
23 import java.util.regex.PatternSyntaxException;
24 
25 /**
26  * Abstract regular expression based predicate implementation. This
27  * class handles parsing of the regexp into a {@link Pattern} object,
28  * and at match time it creates a {@link Matcher} for the annotation
29  * value. Concrete subclasses define the different criteria for what
30  * counts as a "match" in terms of {@link Matcher#find()} and
31  {@link Matcher#matches()}.
32  */
33 public abstract class AbstractRegExpPredicate
34                                              extends
35                                                AbstractConstraintPredicate {
36 
37   private static final long serialVersionUID = 8218973149540251171L;
38 
39   @Override
40   public String toString() {
41     String val = ((Pattern)getValue()).pattern();
42     return getAccessor() + getOperator() "\"" + val + "\"";
43   }
44 
45   @Override
46   public void setValue(Object value) {
47     if(value == nullvalue = "";
48     try {
49       super.setValue(Pattern.compile(value.toString()));
50     }
51     catch(PatternSyntaxException pse) {
52       throw new IllegalArgumentException("Cannot compile pattern '" + value
53               "'");
54     }
55   }
56 
57   /**
58    * Returns true if the given value matches the set pattern. If the
59    * value is null it is treated as an empty string. The actual matching
60    * logic is defined by {@link #matcherResult}.
61    */
62   @Override
63   public boolean doMatch(Object annotValue, AnnotationSet context)
64           throws JapeException {
65 
66     if(annotValue == nullannotValue = "";
67 
68     if(annotValue instanceof String) {
69       String annotValueString = (String)annotValue;
70       Pattern constraintPattern = (Pattern)getValue();
71       return matcherResult(constraintPattern.matcher(annotValueString));
72     }
73     else {
74       throw new JapeException("Cannot do pattern matching on attribute '"
75               + getAccessor() "'.  Are you sure the value is a string?");
76     }
77   }
78 
79   /**
80    * Must be implemented by subclasses to define the matching logic,
81    * typically one of {@link Matcher#find()} and
82    {@link Matcher#matches()}, possibly negated.
83    
84    @param m a {@link Matcher} for the annotation value string,
85    *          obtained from the constraint pattern.
86    @return true if this constraint should be considered to match,
87    *         false otherwise.
88    */
89   protected abstract boolean matcherResult(Matcher m);
90 }