RecordEventSummaryPredicateUtils.java

package com.google.code.joto.eventrecorder.predicate;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.apache.commons.collections.Predicate;
import org.apache.commons.collections.functors.AndPredicate;
import org.apache.commons.collections.functors.EqualPredicate;
import org.apache.commons.collections.functors.FalsePredicate;
import org.apache.commons.collections.functors.NotPredicate;
import org.apache.commons.collections.functors.OrPredicate;
import org.apache.commons.collections.functors.TruePredicate;

import com.google.code.joto.eventrecorder.RecordEventSummary;
import com.google.code.joto.util.PatternsPredicate;
import com.thoughtworks.xstream.XStream;

/**
 * Utility Predicate classes for RecordEventSummary 
 */
public class RecordEventSummaryPredicateUtils {

	public static XStream createDefaultPredicateXStream() {
		XStream res = new XStream();
		registerDefaultXStreamAlias(res);
		return res;
	}
	
	public static void registerDefaultXStreamAlias(XStream res) {
		res.alias("And", AndPredicate.class);
		res.alias("Or", OrPredicate.class);
		res.alias("Not", NotPredicate.class);

		res.alias("Equal", EqualPredicate.class);
		res.alias("True", TruePredicate.class);
		res.alias("False", FalsePredicate.class);

		res.alias("DefaultEventPredicate", DefaultEventTypeRecordEventSummaryPredicate.class);
		
		res.alias("ClassMethodEquals", ClassMethodPatternRecordEventSummaryPredicate.class);
		res.alias("TypeSubTypeEquals", TypeSubTypePatternRecordEventSummaryPredicate.class);
		
	}
	
	public static Predicate snewDefaultClassMethodPredicate(String className, String methodName) {
		List<String> classNameIncludes = null;
		if (className != null) {
			classNameIncludes = new ArrayList<String>();
			classNameIncludes.add(className);
		}
		List<String> methodNameIncludes = null;
		if (methodName != null) {
			methodNameIncludes = new ArrayList<String>();
			methodNameIncludes.add(methodName);
		}
		
		ClassMethodPatternRecordEventSummaryPredicate res = 
				new ClassMethodPatternRecordEventSummaryPredicate(classNameIncludes,
						null, methodNameIncludes, null);
		return res;
	}

	// ------------------------------------------------------------------------
	
	public static abstract class AbstractRecordEventSummaryPredicate implements RecordEventSummaryPredicate, Serializable {

		/** internal for java.io.Serializable */
		private static final long serialVersionUID = 1L;
		
		@Override
		public boolean evaluate(Object obj) {
			if (obj == null || !(obj instanceof RecordEventSummary)) return false;
			else return evaluate((RecordEventSummary) obj);
		}
		
	}

	/**
	 * Predicate with basic conditions on <code>eventType</code> and <code>eventSubType</code>   
	 */
	public static class TypeSubTypePatternRecordEventSummaryPredicate extends AbstractRecordEventSummaryPredicate {

		/** internal for java.io.Serializable */
		private static final long serialVersionUID = 1L;
		
		private final String eventTypeValue;
		private Collection<String> eventSubTypeIncludes;
		private Collection<String> eventSubTypeExcludes;

		/** transient, computed from eventSubTypeIncludes,eventSubTypeExcludes */
		transient private PatternsPredicate _cachedEventSubTypePatterns;
		
		public TypeSubTypePatternRecordEventSummaryPredicate(
				String eventTypeValue, 
				Collection<String> eventSubTypeIncludes, Collection<String> eventSubTypeExcludes) {
			super();
			this.eventTypeValue = eventTypeValue;
			this.eventSubTypeIncludes = eventSubTypeIncludes;
			this.eventSubTypeExcludes = eventSubTypeExcludes;
			this._cachedEventSubTypePatterns = PatternsPredicate.snewCompilePatterns(eventSubTypeIncludes, eventSubTypeExcludes);
		}

		@Override
		public boolean evaluate(RecordEventSummary evt) {
			if (eventTypeValue != null 
					&& !eventTypeValue.equals(evt.getEventType())) {
				return false;
			}
			if (_cachedEventSubTypePatterns == null) {
				this._cachedEventSubTypePatterns = PatternsPredicate.snewCompilePatterns(eventSubTypeIncludes, eventSubTypeExcludes);
			}
			if (_cachedEventSubTypePatterns != null 
					&& !_cachedEventSubTypePatterns.evaluate(evt.getEventSubType())) {
				return false;
			}
			return true;
		}
		
	}
	
	

	/**
	 * Predicate with basic conditions on <code>ClassName</code>, <code>MethodName</code>
	 */
	public static class ClassMethodPatternRecordEventSummaryPredicate extends AbstractRecordEventSummaryPredicate {

		/** internal for java.io.Serializable */
		private static final long serialVersionUID = 1L;
		
		private final List<String> classNameIncludes;
		private final List<String> classNameExcludes;

		private final List<String> methodNameIncludes;
		private final List<String> methodNameExcludes;		
		
		/** transient, computed from classNameIncludes,classNameExcludes */
		transient private PatternsPredicate _cachedClassNamePatterns;
		/** transient, computed from methodNameIncludes,methodNameExcludes */
		transient private PatternsPredicate _cachedMethodNamePatterns;
		
		public ClassMethodPatternRecordEventSummaryPredicate(
				List<String> classNameIncludes,
				List<String> classNameExcludes,
				List<String> methodNameIncludes,
				List<String> methodNameExcludes) {
			super();
			this.classNameIncludes = classNameIncludes;
			this.classNameExcludes = classNameExcludes;
			this._cachedClassNamePatterns = PatternsPredicate.snewCompilePatterns(classNameIncludes, classNameExcludes);
			this.methodNameIncludes = methodNameIncludes;
			this.methodNameExcludes = methodNameExcludes;
			this._cachedMethodNamePatterns = PatternsPredicate.snewCompilePatterns(methodNameIncludes, methodNameExcludes);
		}

		@Override
		public boolean evaluate(RecordEventSummary evt) {
			if (_cachedClassNamePatterns == null) {
				this._cachedClassNamePatterns = PatternsPredicate.snewCompilePatterns(classNameIncludes, classNameExcludes);
			}
			if (_cachedClassNamePatterns != null 
					&& !_cachedClassNamePatterns.evaluate(evt.getEventClassName())) {
				return false;
			}
			if (_cachedMethodNamePatterns == null) {
				this._cachedMethodNamePatterns = PatternsPredicate.snewCompilePatterns(methodNameIncludes, methodNameExcludes);
			}
			if (_cachedMethodNamePatterns != null 
					&& !_cachedMethodNamePatterns.evaluate(evt.getEventMethodName())) {
				return false;
			}
			return true;
		}
		
	}

}