You are viewing a plain text version of this content. The canonical link for it is here.
Posted to log4j-dev@logging.apache.org by ps...@apache.org on 2003/10/10 00:06:51 UTC
cvs commit: jakarta-log4j/src/java/org/apache/log4j/chainsaw RuleMediator.java
psmith 2003/10/09 15:06:51
Modified: src/java/org/apache/log4j/chainsaw RuleMediator.java
Log:
When the LoggerRule is set, this class now listens
for the Rule changing, and propagates this internal
rule change event to external parties. When an internal
rule changes, it effectively means this outter rule changes.
Revision Changes Path
1.3 +136 -100 jakarta-log4j/src/java/org/apache/log4j/chainsaw/RuleMediator.java
Index: RuleMediator.java
===================================================================
RCS file: /home/cvs/jakarta-log4j/src/java/org/apache/log4j/chainsaw/RuleMediator.java,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- RuleMediator.java 17 Sep 2003 01:21:17 -0000 1.2
+++ RuleMediator.java 9 Oct 2003 22:06:51 -0000 1.3
@@ -46,124 +46,160 @@
* Apache Software Foundation, please see <http://www.apache.org/>.
*
*/
+
package org.apache.log4j.chainsaw;
import org.apache.log4j.chainsaw.rule.AbstractRule;
import org.apache.log4j.chainsaw.rule.Rule;
import org.apache.log4j.spi.LoggingEvent;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+
/**
* A mediator class that implements the Rule interface, by combining several optional
* rules used by Chainsaw's filtering GUI's into a single Rule.
- *
- * This class is based upon the concept of Inclusion, Exclusion and Refinement.
+ *
+ * This class is based upon the concept of Inclusion, Exclusion and Refinement.
* By default, this class accepts all events by returning true as part of the Rule interface, unless
* the Inclusion/Exclusion/Refinement sub-rules have been configured.
- *
+ *
* The sub-rules are queried in this order: Inclusion, Refinement, Exclusion. If any are null, that particular
* sub-rule is not queried. If any of the sub-rules returns false, this mediator returns false immediately, otherwise
* they are queried in that order to ensure the overall rule evaluates.
- *
+ *
* Setting the individual sub-rules propagates a PropertyChangeEvent as per standard Java beans principles.
- *
+ *
* @author Paul Smith <ps...@apache.org>
* @author Scott Deboy <sd...@apache.org>
*/
public class RuleMediator extends AbstractRule implements Rule {
-
- private Rule inclusionRule;
- private Rule loggerRule;
- private Rule refinementRule;
- private Rule exclusionRule;
-
- /* (non-Javadoc)
- * @see org.apache.log4j.chainsaw.rule.Rule#evaluate(org.apache.log4j.spi.LoggingEvent)
- */
- public boolean evaluate(LoggingEvent e) {
- boolean accepts = true;
-
- if(inclusionRule!=null) {
- accepts = inclusionRule.evaluate(e);
- }
- if(!accepts) return false;
- if(loggerRule!=null) {
- accepts = loggerRule.evaluate(e);
- }
- if(!accepts) return false;
- if(refinementRule!=null) {
- accepts = refinementRule.evaluate(e);
- }
- if(!accepts) return false;
-
- if(exclusionRule!=null) {
- accepts = exclusionRule.evaluate(e);
- }
- return accepts;
- }
-
- /**
- * Sets the Inclusion rule to be used, and fires a PropertyChangeEvent to listeners
- * @param r
- */
- public void setInclusionRule(Rule r) {
- Rule oldRule = this.inclusionRule;
- this.inclusionRule = r;
- firePropertyChange("inclusionRule", oldRule, this.inclusionRule);
- }
-
- /**
- * Sets the Refinement rule to be used, and fires a PropertyChangeEvent to listeners
- * @param r
- */
- public void setRefinementRule(Rule r) {
- Rule oldRefinementRule = this.refinementRule;
- this.refinementRule = r;
- firePropertyChange("refinementRule", oldRefinementRule, this.refinementRule);
- }
-
- public void setLoggerRule(Rule r) {
- Rule oldLoggerRule = this.loggerRule;
- this.loggerRule = r;
- firePropertyChange("loggerRule", oldLoggerRule, this.loggerRule);
- }
-
- /**
- * Sets the Exclusion rule to be used, and fires a PropertyChangeEvent to listeners.
- *
- * @param r
- */
- public void setExclusionRule(Rule r) {
- Rule oldExclusionRule = this.exclusionRule;
- this.exclusionRule = r;
- firePropertyChange("exclusionRule", oldExclusionRule, this.exclusionRule);
- }
- /**
- * @return
- */
- public final Rule getExclusionRule() {
- return exclusionRule;
- }
-
- /**
- * @return
- */
- public final Rule getInclusionRule() {
- return inclusionRule;
- }
-
- /**
- * @return
- */
- public final Rule getLoggerRule() {
- return loggerRule;
- }
-
- /**
- * @return
- */
- public final Rule getRefinementRule() {
- return refinementRule;
- }
-
+ private Rule inclusionRule;
+ private Rule loggerRule;
+ private Rule refinementRule;
+ private Rule exclusionRule;
+ private final PropertyChangeListener ruleChangerNotifier =
+ new RuleChangerNotifier();
+
+ /* (non-Javadoc)
+ * @see org.apache.log4j.chainsaw.rule.Rule#evaluate(org.apache.log4j.spi.LoggingEvent)
+ */
+ public boolean evaluate(LoggingEvent e) {
+ boolean accepts = true;
+
+ if (inclusionRule != null) {
+ accepts = inclusionRule.evaluate(e);
+ }
+
+ if (!accepts) {
+ return false;
+ }
+
+ if (loggerRule != null) {
+ accepts = loggerRule.evaluate(e);
+ }
+
+ if (!accepts) {
+ return false;
+ }
+
+ if (refinementRule != null) {
+ accepts = refinementRule.evaluate(e);
+ }
+
+ if (!accepts) {
+ return false;
+ }
+
+ if (exclusionRule != null) {
+ accepts = exclusionRule.evaluate(e);
+ }
+
+ return accepts;
+ }
+
+ /**
+ * Sets the Inclusion rule to be used, and fires a PropertyChangeEvent to listeners
+ * @param r
+ */
+ public void setInclusionRule(Rule r) {
+ Rule oldRule = this.inclusionRule;
+ this.inclusionRule = r;
+ firePropertyChange("inclusionRule", oldRule, this.inclusionRule);
+ }
+
+ /**
+ * Sets the Refinement rule to be used, and fires a PropertyChangeEvent to listeners
+ * @param r
+ */
+ public void setRefinementRule(Rule r) {
+ Rule oldRefinementRule = this.refinementRule;
+ this.refinementRule = r;
+ firePropertyChange(
+ "refinementRule", oldRefinementRule, this.refinementRule);
+ }
+
+ public void setLoggerRule(Rule r) {
+ Rule oldLoggerRule = this.loggerRule;
+ this.loggerRule = r;
+ if(oldLoggerRule!=null){
+ oldLoggerRule.removePropertyChangeListener(ruleChangerNotifier);
+ }
+ this.loggerRule.addPropertyChangeListener(ruleChangerNotifier);
+ firePropertyChange("loggerRule", oldLoggerRule, this.loggerRule);
+ }
+
+ /**
+ * Sets the Exclusion rule to be used, and fires a PropertyChangeEvent to listeners.
+ *
+ * @param r
+ */
+ public void setExclusionRule(Rule r) {
+ Rule oldExclusionRule = this.exclusionRule;
+ this.exclusionRule = r;
+ firePropertyChange("exclusionRule", oldExclusionRule, this.exclusionRule);
+ }
+
+ /**
+ * @return
+ */
+ public final Rule getExclusionRule() {
+ return exclusionRule;
+ }
+
+ /**
+ * @return
+ */
+ public final Rule getInclusionRule() {
+ return inclusionRule;
+ }
+
+ /**
+ * @return
+ */
+ public final Rule getLoggerRule() {
+ return loggerRule;
+ }
+
+ /**
+ * @return
+ */
+ public final Rule getRefinementRule() {
+ return refinementRule;
+ }
+
+ /**
+ * Helper class that propagates internal Rules propertyChange events
+ * to external parties, since an internal rule changing really means
+ * this outter rule is going to change too.
+ */
+ private class RuleChangerNotifier implements PropertyChangeListener {
+ /* (non-Javadoc)
+ * @see java.beans.PropertyChangeListener#propertyChange(java.beans.PropertyChangeEvent)
+ */
+ public void propertyChange(PropertyChangeEvent evt) {
+ RuleMediator.this.firePropertyChange(evt);
+ }
+ }
}
---------------------------------------------------------------------
To unsubscribe, e-mail: log4j-dev-unsubscribe@jakarta.apache.org
For additional commands, e-mail: log4j-dev-help@jakarta.apache.org