| /******************************************************************************* |
| * Copyright (c) 2018 École Polytechnique de Montréal |
| * |
| * All rights reserved. This program and the accompanying materials are |
| * made available under the terms of the Eclipse Public License 2.0 which |
| * accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| *******************************************************************************/ |
| |
| package org.eclipse.tracecompass.internal.tmf.core.filter; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.List; |
| import java.util.Objects; |
| |
| import org.apache.commons.lang3.StringUtils; |
| import org.eclipse.jdt.annotation.NonNullByDefault; |
| import org.eclipse.jdt.annotation.Nullable; |
| import org.eclipse.tracecompass.internal.provisional.tmf.core.model.filter.parser.FilterCu; |
| import org.eclipse.tracecompass.internal.provisional.tmf.core.model.filter.parser.IFilterStrings; |
| import org.eclipse.tracecompass.internal.tmf.core.Activator; |
| import org.eclipse.tracecompass.tmf.core.event.aspect.ITmfEventAspect; |
| import org.eclipse.tracecompass.tmf.core.event.aspect.TmfBaseAspects; |
| import org.eclipse.tracecompass.tmf.core.event.aspect.TmfEventFieldAspect; |
| import org.eclipse.tracecompass.tmf.core.filter.ITmfFilter; |
| import org.eclipse.tracecompass.tmf.core.filter.model.TmfFilterAndNode; |
| import org.eclipse.tracecompass.tmf.core.filter.model.TmfFilterAspectNode; |
| import org.eclipse.tracecompass.tmf.core.filter.model.TmfFilterCompareNode; |
| import org.eclipse.tracecompass.tmf.core.filter.model.TmfFilterContainsNode; |
| import org.eclipse.tracecompass.tmf.core.filter.model.TmfFilterEqualsNode; |
| import org.eclipse.tracecompass.tmf.core.filter.model.TmfFilterMatchesNode; |
| import org.eclipse.tracecompass.tmf.core.filter.model.TmfFilterNode; |
| import org.eclipse.tracecompass.tmf.core.filter.model.TmfFilterOrNode; |
| import org.eclipse.tracecompass.tmf.core.filter.model.TmfFilterRootNode; |
| import org.eclipse.tracecompass.tmf.core.filter.model.TmfFilterTreeNode; |
| import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace; |
| |
| /** |
| * Helper class to convert to/from {@link ITmfFilter} and filter regexes |
| * |
| * @author Geneviève Bastien |
| */ |
| @NonNullByDefault |
| public final class TmfFilterHelper { |
| |
| private static final String SPACE = " "; //$NON-NLS-1$ |
| private static final String QUOTE = "\""; //$NON-NLS-1$ |
| |
| private TmfFilterHelper() { |
| // nothing to do |
| } |
| |
| /** |
| * Build an event filter from the regex string in parameter |
| * |
| * @param regexes |
| * The filter regex |
| * @param trace |
| * The trace this filter applies to |
| * @return An event filter |
| */ |
| public static @Nullable ITmfFilter buildFilterFromRegex(Collection<String> regexes, ITmfTrace trace) { |
| FilterCu compile = FilterCu.compile(IFilterStrings.mergeFilters(regexes)); |
| if (compile == null) { |
| Activator.logInfo("buildFilterFromRegex: Invalid regex"); //$NON-NLS-1$ |
| return null; |
| } |
| return compile.getEventFilter(trace); |
| } |
| |
| /** |
| * Get the regex that corresponds to this filter. The regex should be in the |
| * filter language described in the |
| * {@link org.eclipse.tracecompass.tmf.filter.parser} plugin. And as it may |
| * be used to filter anything, so it may not be the direct string |
| * representing of the original filter. For instance, a ITmfFilter specific |
| * for events will do a smart conversion, so that the parameters of the |
| * filter do not match only events, but are generic enough to match any data |
| * source. |
| * |
| * The default implementation of this method returns a regex that will |
| * return true at all time. |
| * |
| * @param filter |
| * The filter object to convert to regex |
| * |
| * @return The regex String, using the |
| * {@link org.eclipse.tracecompass.tmf.filter.parser} syntax |
| * @since 4.1 |
| */ |
| public static String getRegexFromFilter(ITmfFilter filter) { |
| if (filter instanceof TmfFilterRootNode) { |
| return getRegexFromRootNode((TmfFilterRootNode) filter); |
| } |
| if (filter instanceof TmfFilterAndNode) { |
| return getRegexFromAndNode((TmfFilterAndNode) filter); |
| } |
| if (filter instanceof TmfFilterOrNode) { |
| return getRegexFromOrNode((TmfFilterOrNode) filter); |
| } |
| if (filter instanceof TmfFilterCompareNode) { |
| return getRegexFromCompareNode((TmfFilterCompareNode) filter); |
| } |
| if (filter instanceof TmfFilterContainsNode) { |
| return getRegexFromContainsNode((TmfFilterContainsNode) filter); |
| } |
| if (filter instanceof TmfFilterEqualsNode) { |
| return getRegexFromEqualsNode((TmfFilterEqualsNode) filter); |
| } |
| if (filter instanceof TmfFilterMatchesNode) { |
| return getRegexFromMatchesNode((TmfFilterMatchesNode) filter); |
| } |
| if (filter instanceof TmfFilterNode) { |
| return joinChildrenRegex((TmfFilterNode) filter, IFilterStrings.AND); |
| } |
| // Return an empty regex by default |
| return ""; //$NON-NLS-1$ |
| } |
| |
| private static String getRegexFromMatchesNode(TmfFilterMatchesNode filter) { |
| // Special case if the filter value is a wildcard, maps to present regex |
| if (filter.getRegex().equals(".*")) { //$NON-NLS-1$ |
| String regex = quote(getFilterAspectName(filter)) + SPACE + IFilterStrings.PRESENT; |
| return filter.isNot() ? not(regex) : regex; |
| } |
| String regex = quote(getFilterAspectName(filter)) + SPACE + IFilterStrings.MATCHES + SPACE + quote(filter.getRegex()); |
| return filter.isNot() ? not(regex) : regex; |
| } |
| |
| private static String getRegexFromEqualsNode(TmfFilterEqualsNode filter) { |
| return quote(getFilterAspectName(filter)) + SPACE + (filter.isNot() ? IFilterStrings.NOT_EQUAL : IFilterStrings.EQUAL) + SPACE + quote(filter.getValue()); |
| } |
| |
| private static String getRegexFromContainsNode(TmfFilterContainsNode filter) { |
| String regex = quote(getFilterAspectName(filter)) + SPACE + IFilterStrings.CONTAINS + SPACE + quote(filter.getValue()); |
| return filter.isNot() ? not(regex) : regex; |
| } |
| |
| private static String getRegexFromCompareNode(TmfFilterCompareNode filter) { |
| String regex = quote(getFilterAspectName(filter)) + SPACE + getCompareSign(filter.getResult()) + SPACE + quote(filter.getValue()); |
| return filter.isNot() ? not(regex) : regex; |
| } |
| |
| private static String not(String string) { |
| return "!(" + string + ")"; //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| |
| private static String quote(@Nullable String string) { |
| if (string == null) { |
| throw new NullPointerException("unexpected null string in the filter"); //$NON-NLS-1$ |
| } |
| return QUOTE + string + QUOTE; |
| } |
| |
| private static String getCompareSign(int result) { |
| if (result < 0) { |
| return IFilterStrings.LT; |
| } |
| if (result == 0) { |
| return IFilterStrings.EQUAL; |
| } |
| return IFilterStrings.GT; |
| } |
| |
| private static String getFilterAspectName(TmfFilterAspectNode filter) { |
| ITmfEventAspect<?> aspect = filter.getEventAspect(); |
| // The event filter is on the content, just use a wildcard for field |
| if (aspect == TmfBaseAspects.getContentsAspect()) { |
| return IFilterStrings.WILDCARD; |
| } |
| String name = aspect.getName(); |
| if (aspect instanceof TmfEventFieldAspect) { |
| TmfEventFieldAspect eventAspect = (TmfEventFieldAspect) aspect; |
| String fieldPath = eventAspect.getFieldPath(); |
| if (fieldPath != null) { |
| name = fieldPath; |
| } else { |
| // Could be an empty field aspect, so if the name if the same as |
| // the content aspect, return a wildcard |
| if (eventAspect.getName().equals(TmfBaseAspects.getContentsAspect().getName())) { |
| return IFilterStrings.WILDCARD; |
| } |
| } |
| } |
| // Keep only the last element of the path, after the last slash |
| int slashPos = name.lastIndexOf("/"); //$NON-NLS-1$ |
| return slashPos < 0 ? name : name.substring(slashPos); |
| } |
| |
| private static String getRegexFromOrNode(TmfFilterOrNode filter) { |
| String regex = joinChildrenRegex(filter, IFilterStrings.OR); |
| return filter.isNot() ? not(regex) : regex; |
| } |
| |
| private static String getRegexFromAndNode(TmfFilterAndNode filter) { |
| String regex = joinChildrenRegex(filter, IFilterStrings.AND); |
| return filter.isNot() ? not(regex) : regex; |
| } |
| |
| private static String getRegexFromRootNode(TmfFilterRootNode filter) { |
| return joinChildrenRegex(filter, IFilterStrings.AND); |
| } |
| |
| private static String joinChildrenRegex(TmfFilterTreeNode filter, String joinString) { |
| List<String> regexes = new ArrayList<>(); |
| for (ITmfFilter childFilter : filter.getChildren()) { |
| String regex = getRegexFromFilter(childFilter); |
| if (!regex.isEmpty()) { |
| regexes.add(regex); |
| } |
| } |
| return Objects.requireNonNull(StringUtils.join(regexes, SPACE + joinString + SPACE)); |
| } |
| |
| } |
