/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.apache.ivy.core.event;
import org.apache.ivy.plugins.matcher.ExactPatternMatcher;
import org.apache.ivy.plugins.matcher.Matcher;
import org.apache.ivy.plugins.matcher.PatternMatcher;
import org.apache.ivy.util.filter.AndFilter;
import org.apache.ivy.util.filter.Filter;
import org.apache.ivy.util.filter.NoFilter;
import org.apache.ivy.util.filter.NotFilter;
import org.apache.ivy.util.filter.OrFilter;
/**
* A filter implementation filtering {@link IvyEvent} based upon an event name and a filter
* expression. The name will be matched against the event name using the {@link PatternMatcher} used
* to construct this object. The filter expression is a string describing how the event should be
* filtered according to its attributes values. The matching between the filter values and the event
* attribute values is done using the {@link PatternMatcher} used to construct this object. Here are
* some examples:
* <table>
* <tr>
* <td>expression</td>
* <td>effect</td>
* </tr>
* <tr>
* <td>type=zip</td>
* <td>accepts event with a type attribute matching zip</td>
* </tr>
* <tr>
* <td>type=zip,jar</td>
* <td>accepts event with a type attribute matching zip or jar</td>
* </tr>
* <tr>
* <td>type=src AND ext=zip</td>
* <td>accepts event with a type attribute matching src AND an ext attribute matching zip</td>
* </tr>
* <tr>
* <td>type=src OR ext=zip</td>
* <td>accepts event with a type attribute matching src OR an ext attribute matching zip</td>
* </tr>
* <tr>
* <td>NOT type=src</td>
* <td>accepts event with a type attribute NOT matching src</td>
* </tr>
* </table>
* Combination of these can be used, but no parentheses are supported right now, so only the default
* priority can be used. The priority order is this one: AND OR NOT = This means that artifact=foo
* AND ext=zip OR type=src will match event with artifact matching foo AND (ext matching zip OR type
* matching src)
*
* @since 1.4
*/
public class IvyEventFilter implements Filter {
private static final String NOT = "NOT ";
private static final String OR = " OR ";
private static final String AND = " AND ";
private PatternMatcher matcher;
private Filter nameFilter;
private Filter attFilter;
public IvyEventFilter(String event, String filterExpression, PatternMatcher matcher) {
this.matcher = matcher == null ? ExactPatternMatcher.INSTANCE : matcher;
if (event == null) {
nameFilter = NoFilter.INSTANCE;
} else {
final Matcher eventNameMatcher = this.matcher.getMatcher(event);
nameFilter = new Filter() {
public boolean accept(Object o) {
IvyEvent e = (IvyEvent) o;
return eventNameMatcher.matches(e.getName());
}
};
}
attFilter = filterExpression == null || filterExpression.trim().length() == 0 ? NoFilter.INSTANCE
: parseExpression(filterExpression);
}
private Filter parseExpression(String filterExpression) {
// expressions handled for the moment: (informal grammar)
// EXP := SIMPLE_EXP | AND_EXP | OR_EXP | NOT_EXP
// AND_EXP := EXP && EXP
// OR_EXP := EXP || EXP
// NOT_EXP := ! EXP
// SIMPLE_EXP := attname = comma, separated, list, of, accepted, values
// example: organisation = foo && module = bar, baz
filterExpression = filterExpression.trim();
int index = filterExpression.indexOf(AND);
if (index == -1) {
index = filterExpression.indexOf(OR);
if (index == -1) {
if (filterExpression.startsWith(NOT)) {
return new NotFilter(parseExpression(filterExpression.substring(NOT.length())));
} else {
index = filterExpression.indexOf("=");
if (index == -1) {
throw new IllegalArgumentException("bad filter expression: "
+ filterExpression + ": no equal sign found");
}
final String attname = filterExpression.substring(0, index).trim();
String[] values = filterExpression.substring(index + 1).trim().split(",");
final Matcher[] matchers = new Matcher[values.length];
for (int i = 0; i < values.length; i++) {
matchers[i] = matcher.getMatcher(values[i].trim());
}
return new Filter() {
public boolean accept(Object o) {
IvyEvent e = (IvyEvent) o;
String val = (String) e.getAttributes().get(attname);
if (val == null) {
return false;
}
for (int i = 0; i < matchers.length; i++) {
if (matchers[i].matches(val)) {
return true;
}
}
return false;
}
};
}
} else {
return new OrFilter(parseExpression(filterExpression.substring(0, index)),
parseExpression(filterExpression.substring(index + OR.length())));
}
} else {
return new AndFilter(parseExpression(filterExpression.substring(0, index)),
parseExpression(filterExpression.substring(index + AND.length())));
}
}
public boolean accept(Object o) {
if (!(o instanceof IvyEvent)) {
return false;
}
return nameFilter.accept(o) && attFilter.accept(o);
}
}