KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > prefuse > data > expression > CompositePredicate


1 package prefuse.data.expression;
2
3 import java.util.ArrayList JavaDoc;
4 import java.util.Iterator JavaDoc;
5
6 /**
7  * Abstract base class for Predicate instances that maintain one or
8  * more sub-predicates (clauses).
9  *
10  * @author <a HREF="http://jheer.org">jeffrey heer</a>
11  */
12 public abstract class CompositePredicate extends AbstractPredicate {
13
14     protected ArrayList JavaDoc m_clauses = new ArrayList JavaDoc(2);
15     
16     /**
17      * Create a new, empty CompositePredicate.
18      */
19     public CompositePredicate() {
20     }
21     
22     /**
23      * Create a new CompositePredicate.
24      * @param p1 the first sub-predicate
25      * @param p2 the second sub-predicate
26      */
27     public CompositePredicate(Predicate p1, Predicate p2) {
28         m_clauses.add(p1);
29         m_clauses.add(p2);
30     }
31     
32     // ------------------------------------------------------------------------
33
34     /**
35      * Add a new clause.
36      * @param p the Predicate clause to add
37      */
38     public void add(Predicate p) {
39         if ( m_clauses.contains(p) ) {
40             throw new IllegalArgumentException JavaDoc("Duplicate predicate.");
41         }
42         m_clauses.add(p);
43         fireExpressionChange();
44     }
45     
46     /**
47      * Remove a new clause.
48      * @param p the Predicate clause to remove
49      * @return true if removed, false if not found
50      */
51     public boolean remove(Predicate p) {
52         if ( m_clauses.remove(p) ) {
53             fireExpressionChange();
54             return true;
55         } else {
56             return false;
57         }
58     }
59     
60     /**
61      * Remove all clauses.
62      */
63     public void clear() {
64         removeChildListeners();
65         m_clauses.clear();
66         fireExpressionChange();
67     }
68     
69     /**
70      * Get the number of sub-predicate clauses.
71      * @return the number of clauses
72      */
73     public int size() {
74         return m_clauses.size();
75     }
76     
77     /**
78      * Get the sub-predicate at the given index.
79      * @param idx the index to lookup
80      * @return the sub-predicate at the given index
81      */
82     public Predicate get(int idx) {
83         return (Predicate)m_clauses.get(idx);
84     }
85     
86     /**
87      * Set the given predicate to be the only clause of thie composite.
88      * @param p the new sole sub-predicate clause
89      */
90     public void set(Predicate p) {
91         removeChildListeners();
92         m_clauses.clear();
93         m_clauses.add(p);
94         if ( hasListeners() ) addChildListeners();
95         fireExpressionChange();
96     }
97     
98     /**
99      * Set the given predicates to be the clauses of thie composite.
100      * @param p the new sub-predicate clauses
101      */
102     public void set(Predicate[] p) {
103         removeChildListeners();
104         m_clauses.clear();
105         for ( int i=0; i<p.length; ++i ) {
106             if ( !m_clauses.contains(p) )
107                 m_clauses.add(p[i]);
108         }
109         if ( hasListeners() ) addChildListeners();
110         fireExpressionChange();
111     }
112     
113     /**
114      * Get a predicate instance just like this one but without
115      * the given predicate as a clause.
116      * @param p the predicate clause to ignore
117      * @return a clone of this predicate, only without the input predicate
118      */
119     public Predicate getSubPredicate(Predicate p) {
120         CompositePredicate cp = null;
121         try {
122             cp = (CompositePredicate)this.getClass().newInstance();
123         } catch (InstantiationException JavaDoc e) {
124             // won't happen
125 } catch (IllegalAccessException JavaDoc e) {
126             // won't happen
127 }
128         for ( int i=0; i<m_clauses.size(); ++i ) {
129             Predicate pp = (Predicate)m_clauses.get(i);
130             if ( p != pp ) {
131                 cp.add(pp);
132             }
133         }
134         return cp;
135     }
136     
137     // ------------------------------------------------------------------------
138
139     /**
140      * @see prefuse.data.expression.Expression#visit(prefuse.data.expression.ExpressionVisitor)
141      */
142     public void visit(ExpressionVisitor v) {
143         v.visitExpression(this);
144         Iterator JavaDoc iter = m_clauses.iterator();
145         while ( iter.hasNext() ) {
146             v.down();
147             ((Expression)iter.next()).visit(v);
148             v.up();
149         }
150     }
151     
152     // ------------------------------------------------------------------------
153
154     /**
155      * @see prefuse.data.expression.AbstractExpression#addChildListeners()
156      */
157     protected void addChildListeners() {
158         Iterator JavaDoc iter = m_clauses.iterator();
159         while ( iter.hasNext() ) {
160             ((Expression)iter.next()).addExpressionListener(this);
161         }
162     }
163     
164     /**
165      * @see prefuse.data.expression.AbstractExpression#removeChildListeners()
166      */
167     protected void removeChildListeners() {
168         Iterator JavaDoc iter = m_clauses.iterator();
169         while ( iter.hasNext() ) {
170             ((Expression)iter.next()).removeExpressionListener(this);
171         }
172     }
173     
174     // ------------------------------------------------------------------------
175
176     /**
177      * Return a String representation of this predicate.
178      * @param op a String describing the operation this Predicate performs
179      * @return a String representing this Expression
180      */
181     protected String JavaDoc toString(String JavaDoc op) {
182         if ( m_clauses.size() == 1 ) {
183             return m_clauses.get(0).toString();
184         }
185         
186         StringBuffer JavaDoc sbuf = new StringBuffer JavaDoc();
187         sbuf.append('(');
188
189         Iterator JavaDoc iter = m_clauses.iterator();
190         while ( iter.hasNext() ) {
191             sbuf.append(iter.next().toString());
192             if ( iter.hasNext() ) {
193                 sbuf.append(" ");
194                 sbuf.append(op);
195                 sbuf.append(" ");
196             }
197         }
198         
199         sbuf.append(')');
200         return sbuf.toString();
201     }
202
203 } // end of abstract class CompositePredicate
204
Popular Tags