KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > prefuse > data > search > RegexSearchTupleSet


1 package prefuse.data.search;
2
3 import java.util.Iterator JavaDoc;
4 import java.util.LinkedHashMap JavaDoc;
5 import java.util.logging.Logger JavaDoc;
6 import java.util.regex.Pattern JavaDoc;
7
8 import prefuse.data.Tuple;
9 import prefuse.data.tuple.DefaultTupleSet;
10 import prefuse.data.tuple.TupleSet;
11 import prefuse.util.StringLib;
12
13 /**
14  * SearchTupleSet implementation that treats the query as a regular expression
15  * to match against all indexed Tuple data fields.
16  * The regular expression engine provided by the
17  * standard Java libraries
18  * ({@link java.util.regex.Pattern java.util.regex.Pattern}) is used; please
19  * refer to the documentation for that class for more about the regular
20  * expression syntax.
21  *
22  * @author <a HREF="http://jheer.org">jeffrey heer</a>
23  * @see prefuse.data.query.SearchQueryBinding
24  */
25 public class RegexSearchTupleSet extends SearchTupleSet {
26     
27     private String JavaDoc m_query = "";
28     private boolean m_caseSensitive;
29     private LinkedHashMap JavaDoc m_source = new LinkedHashMap JavaDoc();
30     
31     /**
32      * Create a new, case-insensitive regular expression search tuple set.
33      */
34     public RegexSearchTupleSet() {
35         this(false);
36     }
37     
38     /**
39      * Create a new regular expression search tuple set.
40      * @param caseSensitive true to make the indexing case sensitive, false
41      * otherwise.
42      */
43     public RegexSearchTupleSet(boolean caseSensitive) {
44         m_caseSensitive = caseSensitive;
45     }
46     
47     /**
48      * @see prefuse.data.search.SearchTupleSet#getQuery()
49      */
50     public String JavaDoc getQuery() {
51         return m_query;
52     }
53
54     /**
55      * @see prefuse.data.search.SearchTupleSet#search(java.lang.String)
56      */
57     public void search(String JavaDoc query) {
58         if ( query == null )
59             query = "";
60         if ( !m_caseSensitive )
61             query = query.toLowerCase();
62         if ( query.equals(m_query) )
63             return;
64         
65         Pattern JavaDoc pattern = null;
66         try {
67             pattern = Pattern.compile(query);
68         } catch ( Exception JavaDoc e ) {
69             Logger JavaDoc logger = Logger.getLogger(this.getClass().getName());
70             logger.warning("Pattern compile failed."
71                     + "\n" + StringLib.getStackTrace(e));
72             return;
73         }
74         
75         Tuple[] rem = clearInternal();
76         m_query = query;
77         Iterator JavaDoc fields = m_source.keySet().iterator();
78         while ( fields.hasNext() ) {
79             String JavaDoc field = (String JavaDoc)fields.next();
80             TupleSet ts = (TupleSet)m_source.get(field);
81             
82             Iterator JavaDoc tuples = ts.tuples();
83             while ( tuples.hasNext() ) {
84                 Tuple t = (Tuple)tuples.next();
85                 String JavaDoc text = t.getString(field);
86                 if ( !m_caseSensitive )
87                     text = text.toLowerCase();
88                 
89                 if ( pattern.matcher(text).matches() )
90                     addInternal(t);
91             }
92         }
93         Tuple[] add = getTupleCount() > 0 ? toArray() : null;
94         fireTupleEvent(add, rem);
95     }
96
97     /**
98      * @see prefuse.data.search.SearchTupleSet#index(prefuse.data.Tuple, java.lang.String)
99      */
100     public void index(Tuple t, String JavaDoc field) {
101         TupleSet ts = (TupleSet)m_source.get(field);
102         if ( ts == null ) {
103             ts = new DefaultTupleSet();
104             m_source.put(field, ts);
105         }
106         ts.addTuple(t);
107     }
108
109     /**
110      * @see prefuse.data.search.SearchTupleSet#unindex(prefuse.data.Tuple, java.lang.String)
111      */
112     public void unindex(Tuple t, String JavaDoc field) {
113         TupleSet ts = (TupleSet)m_source.get(field);
114         if ( ts != null ) {
115             ts.removeTuple(t);
116         }
117     }
118
119     /**
120      * Returns true, as unidexing is supported by this class.
121      * @see prefuse.data.search.SearchTupleSet#isUnindexSupported()
122      */
123     public boolean isUnindexSupported() {
124         return true;
125     }
126     
127     /**
128      * Removes all search hits and clears out the index.
129      * @see prefuse.data.tuple.TupleSet#clear()
130      */
131     public void clear() {
132         m_source.clear();
133         super.clear();
134     }
135
136 } // end of class RegexSearchTupleSet
137
Popular Tags