tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/internal/provisional/tmf/core/model/filter/parser/FilterSimpleExpressionCu.java - tracecompass/org.eclipse.tracecompass - Git at Google

 /*******************************************************************************
  * Copyright (c) 2018, 2019 Ericsson
  *
  * 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.provisional.tmf.core.model.filter.parser;

 import java.text.Format;
 import java.text.NumberFormat;
 import java.text.ParseException;
 import java.text.ParsePosition;
 import java.util.Objects;
 import java.util.function.BiFunction;
 import java.util.function.BiPredicate;
 import java.util.regex.Pattern;
 import java.util.regex.PatternSyntaxException;

 import org.antlr.runtime.tree.CommonTree;
 import org.antlr.runtime.tree.Tree;
 import org.eclipse.jdt.annotation.Nullable;
 import org.eclipse.tracecompass.common.core.format.DecimalUnitFormat;
 import org.eclipse.tracecompass.common.core.format.SubSecondTimeWithUnitFormat;
 import org.eclipse.tracecompass.tmf.core.event.aspect.ITmfEventAspect;
 import org.eclipse.tracecompass.tmf.core.event.aspect.TmfBaseAspects;
 import org.eclipse.tracecompass.tmf.core.filter.model.ITmfFilterTreeNode;
 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.TmfFilterOrNode;
 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestampFormat;
 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
 import org.eclipse.tracecompass.tmf.core.util.Pair;
 import org.eclipse.tracecompass.tmf.filter.parser.FilterParserParser;

 /**
  * Compilation unit for a simple filter expression
  *
  * @author Jean-Christian Kouame
  *
  */
 public class FilterSimpleExpressionCu implements IFilterCu {

     private static final Format DECIMAL_FORMAT = new DecimalUnitFormat();

     private final String fField;
     private final String fOperator;
     private final @Nullable String fValue;

     /**
      * Constructor
      *
      * @param field
      *            The field to look for
      * @param op
      *            The operator to use for the test
      * @param value
      *            The value to to test
      */
     public FilterSimpleExpressionCu(String field, String op, @Nullable String value) {
         fField = field;
         fOperator = op;
         fValue = value;
     }

     /**
      * Get the filter field parameter
      *
      * @return the field parameter
      */
     protected String getField() {
         return fField;
     }

     /**
      * Get the filter operator
      *
      * @return The filter operator
      */
     protected String getOperator() {
         return fOperator;
     }

     /**
      * Get the filter value parameter
      *
      * @return The value parameter
      */
     protected @Nullable String getValue() {
         return fValue;
     }

     /**
      * Compile a simple filter expression compilation unit from a tree
      *
      * @param tree
      *            The input tree
      * @return The simple filter expression compilation unit
      */
     public static @Nullable FilterSimpleExpressionCu compile(CommonTree tree) {
         if (tree.getToken() == null) {
             return null;
         }

         int childCount = tree.getChildCount();
         switch (tree.getToken().getType()) {
         case FilterParserParser.CONSTANT:
         case FilterParserParser.PAR_CONSTANT:
             StringBuilder paragraph = new StringBuilder();
             extractParagraph(tree, paragraph, 0, childCount);
             return new FilterSimpleExpressionCu(IFilterStrings.WILDCARD, IFilterStrings.MATCHES, paragraph.toString().trim());
         case FilterParserParser.OPERATION:
             String left = Objects.requireNonNull(tree.getChild(0).getText());
             String op = Objects.requireNonNull(tree.getChild(1).getText());
             String right = tree.getChild(2).getText();
             return new FilterSimpleExpressionCu(left, op, right);
         case FilterParserParser.OPERATION1:
             String left1 = Objects.requireNonNull(tree.getChild(0).getText());
             String op1 = Objects.requireNonNull(tree.getChild(1).getText());
             String right1 = null;
             return new FilterSimpleExpressionCu(left1, op1, right1);
         case FilterParserParser.OPERATION2:
         case FilterParserParser.OPERATION4:
         case FilterParserParser.OPERATION5:
             StringBuilder builder = new StringBuilder();
             int index = extractParagraph(tree, builder, 0, childCount);
             String left2 = builder.toString().trim();
             String op2 = Objects.requireNonNull(tree.getChild(index++).getText());
             builder = new StringBuilder();
             extractParagraph(tree, builder, index, childCount);
             String right2 = builder.toString().trim();
             return new FilterSimpleExpressionCu(left2, op2, right2);
         case FilterParserParser.OPERATION3:
             StringBuilder builder1 = new StringBuilder();
             int index1 = extractParagraph(tree, builder1, 0, childCount);
             String left3 = builder1.toString().trim();
             String op3 = Objects.requireNonNull(tree.getChild(index1).getText());
             String right3 = null;
             return new FilterSimpleExpressionCu(left3, op3, right3);
         case FilterParserParser.ROOT2:
             if (childCount == 0 || (childCount == 2 && tree.getChild(1).getType() != FilterParserParser.CONSTANT)) {
                 return null;
             }

             boolean negate = tree.getChild(0).getText().equals(IFilterStrings.NOT);
             CommonTree expression = Objects.requireNonNull((CommonTree) tree.getChild(childCount - 1));
             FilterSimpleExpressionCu compiled = negate ? FilterSimpleExpressionNotCu.compile(expression) : FilterSimpleExpressionCu.compile(expression);
             return compiled;
         default:
             break;
         }
         return null;
     }

     private static int extractParagraph(CommonTree tree, StringBuilder builder, int index, int count) {
         String separator = " "; //$NON-NLS-1$
         int i;
         boolean stop = false;
         for (i = index; i < count && !stop; i++) {
             Tree child = tree.getChild(i);
             if (child.getType() != FilterParserParser.TEXT) {
                 stop = true;
                 continue;
             }
             builder.append(child.getText());
             builder.append(separator);
         }
         return --i;
     }

     /**
      * Generates a filter simple expression runtime object
      *
      * @return The filter simple expression
      */
     public FilterSimpleExpression generate() {
         return new FilterSimpleExpression(fField, getConditionOperator(fOperator), fValue);
     }

     /**
      * Get the condition predicate for the operator
      *
      * @param equationType
      *            The operator to convert to predicate
      * @return The condition predicate
      */
     protected static ConditionOperator getConditionOperator(String equationType) {
         switch (equationType) {
         case IFilterStrings.EQUAL:
             return ConditionOperator.EQ;
         case IFilterStrings.NOT_EQUAL:
             return ConditionOperator.NE;
         case IFilterStrings.MATCHES:
             return ConditionOperator.MATCHES;
         case IFilterStrings.CONTAINS:
             return ConditionOperator.CONTAINS;
         case IFilterStrings.PRESENT:
             return ConditionOperator.PRESENT;
         case IFilterStrings.GT:
             return ConditionOperator.GT;
         case IFilterStrings.LT:
             return ConditionOperator.LT;
         default:
             throw new IllegalArgumentException("FilterSimpleExpression: invalid comparison operator."); //$NON-NLS-1$
         }
     }

     /**
      * Condition operators used to compare 2 values together. The first value
      * should be the internal value and the second value the value entered by
      * the user or filter.
      */
     protected enum ConditionOperator implements BiPredicate<Object, Object> {
         /** equal */
         EQ((i, j) -> equals(i, j)),
         /** not equal */
         NE((i, j) -> !equals(i, j)),
         /** Matches */
         MATCHES(matchFunc()),
         /** Contains */
         CONTAINS((i, j) -> String.valueOf(i).contains(String.valueOf(j))),
         /** Less than */
         LT((i, j) -> numericalCompare(i, j) < 0),
         /** Greater than */
         GT((i, j) -> numericalCompare(i, j) > 0),
         /** Field is present */
         PRESENT((i, j) -> true);

         private final BiFunction<Object, Object, Boolean> fCmpFunction;

         ConditionOperator(BiFunction<Object, Object, Boolean> cmpFunction) {
             fCmpFunction = cmpFunction;
         }

         private static BiFunction<Object, Object, Boolean> matchFunc() {
             return (i, j) -> {
                 Pattern filterPattern = null;
                 Object value = j;
                 if (j instanceof Pair) {
                     Pair<?, ?> pair = (Pair<?, ?>) j;
                     if (pair.getFirst() instanceof Pattern) {
                         filterPattern = (Pattern) pair.getFirst();
                     }
                     value = pair.getSecond();
                 }
                 /*
                  * 'value' is the value entered by the user, if it has been
                  * converted to a Number, the equality check is better suited as
                  * the format (hex, decimal) is considered
                  */
                 if (value instanceof Number && equals(i, value)) {
                     return true;
                 }
                 if (filterPattern != null) {
                     return filterPattern.matcher(String.valueOf(i)).find();
                 }
                 return false;
             };
         }

         private static boolean equals(Object i, Object j) {
             // Are objects equal
             if (Objects.equals(i, j)) {
                 return true;
             }
             // Are their String representation equals
             if (Objects.equals(String.valueOf(i), String.valueOf(j))) {
                 return true;
             }
             // Try to convert them to number and see if they are the same
             Number number1 = toNumber(i);
             if (number1 == null) {
                 return false;
             }
             Number number2 = toNumber(j);
             if (number2 == null) {
                 return false;
             }
             if (number1 instanceof Double || number2 instanceof Double
                     || number1 instanceof Float || number2 instanceof Float) {
                 return number1.doubleValue() == number2.doubleValue();
             }
             return number1.longValue() == number2.longValue();
         }

         private static int numericalCompare(Object i, Object j) {
             Number number1 = toNumber(i);
             Number number2 = toNumber(j);
             if (number2 == null || number1 == null) {
                 // Compare their string representation
                 return String.valueOf(i).compareTo(String.valueOf(j));
             } else if (number1 instanceof Double || number2 instanceof Double
                     || number1 instanceof Float || number2 instanceof Float) {
                 return Double.compare(number1.doubleValue(), number2.doubleValue());
             }
             return Long.compare(number1.longValue(), number2.longValue());
         }

         private static @Nullable Number toNumber(Object value) {
             if (value instanceof Number) {
                 return (Number) value;
             }
             String val = String.valueOf(value);
             try {
                 return Long.decode(val);
             } catch (NumberFormatException e) {
             }

             // Try to use some formatters to parse the value
             ParsePosition pos = new ParsePosition(0);
             Number parsed = NumberFormat.getInstance().parse(val, pos);
             // The full string should have been parsed, not just the first
             // numerical characters
             if (pos.getErrorIndex() < 0 && pos.getIndex() == val.length()) {
                 return parsed;
             }

             // Try the decimal with unit formatter
             pos = new ParsePosition(0);
             Object parsedObj = DECIMAL_FORMAT.parseObject(val, pos);
             // The full string should have been parsed, not just the first
             // numerical characters
             if (pos.getErrorIndex() < 0 && pos.getIndex() == val.length() && parsedObj instanceof Number) {
                 return (Number) parsedObj;
             }

             // Try the duration formatter
             pos = new ParsePosition(0);
             parsedObj = SubSecondTimeWithUnitFormat.getInstance().parseObject(val, pos);
             // The full string should have been parsed, not just the first
             // numerical characters
             if (pos.getErrorIndex() < 0 && pos.getIndex() == val.length() && parsedObj instanceof Number) {
                 return (Number) parsedObj;
             }

             // Try the timestamp formatter
             try {
                 return TmfTimestampFormat.getDefaulTimeFormat().parseValue(val);
             } catch (ParseException e) {
                 // Nothing to do
             }

             return null;
         }

         @Override
         public boolean test(Object arg0, Object arg1) {
             return Objects.requireNonNull(fCmpFunction.apply(arg0, arg1));
         }

         /**
          * Convert a human-readable string value to its machine representation.
          * For example, duration strings such as "200ms" can be converted to the
          * long value of 200000000. For the MATCHES operator, return a pair that
          * contains the compiled pattern and the parsed value.
          *
          * @param operator
          *            The operator for which the value is prepared
          * @param value
          *            The human-readable string value entered by the user
          * @return The parsed value as a number if available, or the string
          *         itself if no formatter succeeded, or a pair of the compiled
          *         pattern and the parsed value.
          */
         public static @Nullable Object prepareValue(ConditionOperator operator, @Nullable String value) {
             if (value == null) {
                 return null;
             }
             Object parsedValue = value;
             // Try to convert to a number
             Number number = toNumber(value);
             if (number != null) {
                 parsedValue = number;
             }
             Pattern pattern = null;
             if (operator == ConditionOperator.MATCHES) {
                 // Try to compile to a pattern
                 try {
                     pattern = Pattern.compile(String.valueOf(value));
                 } catch (PatternSyntaxException e) {
                     // Ignore
                 }
                 if (pattern != null) {
                     return new Pair<>(pattern, parsedValue);
                 }
             }
             return parsedValue;
         }
     }

     @Override
     public ITmfFilterTreeNode getEventFilter(ITmfTrace trace) {
         if (fField.equals(IFilterStrings.WILDCARD)) {
             // Make a OR on all aspects
             TmfFilterOrNode orNode = new TmfFilterOrNode(null);
             for (ITmfEventAspect<?> aspect : trace.getEventAspects()) {
                 TmfFilterMatchesNode node = new TmfFilterMatchesNode(null);
                 node.setEventAspect(aspect);
                 node.setRegex(fValue);
                 orNode.addChild(node);
             }
             orNode.setNot(getNot());
             return orNode;
         }
         // Find an event aspect corresponding to the field
         ITmfEventAspect<?> filterAspect = null;
         for (ITmfEventAspect<?> aspect : trace.getEventAspects()) {
             if (aspect.getName().equals(fField)) {
                 filterAspect = aspect;
                 break;
             }
         }
         if (filterAspect == null) {
             // Fallback to a field aspect
             filterAspect = TmfBaseAspects.getContentsAspect().forField(fField);
         }
         TmfFilterAspectNode conditionNode = createConditionNode();
         conditionNode.setEventAspect(filterAspect);

         return conditionNode;
     }

     private TmfFilterAspectNode createConditionNode() {
         switch (fOperator) {
         case IFilterStrings.EQUAL:
             TmfFilterEqualsNode equalsNode = new TmfFilterEqualsNode(null);
             equalsNode.setValue(fValue);
             equalsNode.setNot(getNot());
             return equalsNode;
         case IFilterStrings.NOT_EQUAL:
             TmfFilterEqualsNode notEqualsNode = new TmfFilterEqualsNode(null);
             notEqualsNode.setValue(fValue);
             notEqualsNode.setNot(!getNot());
             return notEqualsNode;
         case IFilterStrings.MATCHES:
             TmfFilterMatchesNode matchesNode = new TmfFilterMatchesNode(null);
             matchesNode.setRegex(fValue);
             matchesNode.setNot(getNot());
             return matchesNode;
         case IFilterStrings.CONTAINS:
             TmfFilterContainsNode containsNode = new TmfFilterContainsNode(null);
             containsNode.setValue(fValue);
             containsNode.setNot(getNot());
             return containsNode;
         case IFilterStrings.PRESENT:
             TmfFilterMatchesNode presentNode = new TmfFilterMatchesNode(null);
             presentNode.setRegex(".*"); //$NON-NLS-1$
             presentNode.setNot(getNot());
             return presentNode;
         case IFilterStrings.GT:
             TmfFilterCompareNode gtNode = new TmfFilterCompareNode(null);
             gtNode.setResult(1);
             gtNode.setValue(fValue);
             gtNode.setNot(getNot());
             return gtNode;
         case IFilterStrings.LT:
             TmfFilterCompareNode ltNode = new TmfFilterCompareNode(null);
             ltNode.setResult(-1);
             ltNode.setValue(fValue);
             ltNode.setNot(getNot());
             return ltNode;
         default:
             throw new IllegalArgumentException("FilterSimpleExpression: invalid comparison operator."); //$NON-NLS-1$
         }
     }

     /**
      * Get whether this Cu expression is a negation
      *
      * @return <code>true</code> if the expression is a negation
      */
     protected boolean getNot() {
         return false;
     }

 }
	/*******************************************************************************
	* Copyright (c) 2018, 2019 Ericsson
	*
	* 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.provisional.tmf.core.model.filter.parser;

	import java.text.Format;
	import java.text.NumberFormat;
	import java.text.ParseException;
	import java.text.ParsePosition;
	import java.util.Objects;
	import java.util.function.BiFunction;
	import java.util.function.BiPredicate;
	import java.util.regex.Pattern;
	import java.util.regex.PatternSyntaxException;

	import org.antlr.runtime.tree.CommonTree;
	import org.antlr.runtime.tree.Tree;
	import org.eclipse.jdt.annotation.Nullable;
	import org.eclipse.tracecompass.common.core.format.DecimalUnitFormat;
	import org.eclipse.tracecompass.common.core.format.SubSecondTimeWithUnitFormat;
	import org.eclipse.tracecompass.tmf.core.event.aspect.ITmfEventAspect;
	import org.eclipse.tracecompass.tmf.core.event.aspect.TmfBaseAspects;
	import org.eclipse.tracecompass.tmf.core.filter.model.ITmfFilterTreeNode;
	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.TmfFilterOrNode;
	import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestampFormat;
	import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
	import org.eclipse.tracecompass.tmf.core.util.Pair;
	import org.eclipse.tracecompass.tmf.filter.parser.FilterParserParser;

	/**
	* Compilation unit for a simple filter expression
	*
	* @author Jean-Christian Kouame
	*
	*/
	public class FilterSimpleExpressionCu implements IFilterCu {

	private static final Format DECIMAL_FORMAT = new DecimalUnitFormat();

	private final String fField;
	private final String fOperator;
	private final @Nullable String fValue;

	/**
	* Constructor
	*
	* @param field
	* The field to look for
	* @param op
	* The operator to use for the test
	* @param value
	* The value to to test
	*/
	public FilterSimpleExpressionCu(String field, String op, @Nullable String value) {
	fField = field;
	fOperator = op;
	fValue = value;
	}

	/**
	* Get the filter field parameter
	*
	* @return the field parameter
	*/
	protected String getField() {
	return fField;
	}

	/**
	* Get the filter operator
	*
	* @return The filter operator
	*/
	protected String getOperator() {
	return fOperator;
	}

	/**
	* Get the filter value parameter
	*
	* @return The value parameter
	*/
	protected @Nullable String getValue() {
	return fValue;
	}

	/**
	* Compile a simple filter expression compilation unit from a tree
	*
	* @param tree
	* The input tree
	* @return The simple filter expression compilation unit
	*/
	public static @Nullable FilterSimpleExpressionCu compile(CommonTree tree) {
	if (tree.getToken() == null) {
	return null;
	}

	int childCount = tree.getChildCount();
	switch (tree.getToken().getType()) {
	case FilterParserParser.CONSTANT:
	case FilterParserParser.PAR_CONSTANT:
	StringBuilder paragraph = new StringBuilder();
	extractParagraph(tree, paragraph, 0, childCount);
	return new FilterSimpleExpressionCu(IFilterStrings.WILDCARD, IFilterStrings.MATCHES, paragraph.toString().trim());
	case FilterParserParser.OPERATION:
	String left = Objects.requireNonNull(tree.getChild(0).getText());
	String op = Objects.requireNonNull(tree.getChild(1).getText());
	String right = tree.getChild(2).getText();
	return new FilterSimpleExpressionCu(left, op, right);
	case FilterParserParser.OPERATION1:
	String left1 = Objects.requireNonNull(tree.getChild(0).getText());
	String op1 = Objects.requireNonNull(tree.getChild(1).getText());
	String right1 = null;
	return new FilterSimpleExpressionCu(left1, op1, right1);
	case FilterParserParser.OPERATION2:
	case FilterParserParser.OPERATION4:
	case FilterParserParser.OPERATION5:
	StringBuilder builder = new StringBuilder();
	int index = extractParagraph(tree, builder, 0, childCount);
	String left2 = builder.toString().trim();
	String op2 = Objects.requireNonNull(tree.getChild(index++).getText());
	builder = new StringBuilder();
	extractParagraph(tree, builder, index, childCount);
	String right2 = builder.toString().trim();
	return new FilterSimpleExpressionCu(left2, op2, right2);
	case FilterParserParser.OPERATION3:
	StringBuilder builder1 = new StringBuilder();
	int index1 = extractParagraph(tree, builder1, 0, childCount);
	String left3 = builder1.toString().trim();
	String op3 = Objects.requireNonNull(tree.getChild(index1).getText());
	String right3 = null;
	return new FilterSimpleExpressionCu(left3, op3, right3);
	case FilterParserParser.ROOT2:
	if (childCount == 0 \|\| (childCount == 2 && tree.getChild(1).getType() != FilterParserParser.CONSTANT)) {
	return null;
	}

	boolean negate = tree.getChild(0).getText().equals(IFilterStrings.NOT);
	CommonTree expression = Objects.requireNonNull((CommonTree) tree.getChild(childCount - 1));
	FilterSimpleExpressionCu compiled = negate ? FilterSimpleExpressionNotCu.compile(expression) : FilterSimpleExpressionCu.compile(expression);
	return compiled;
	default:
	break;
	}
	return null;
	}

	private static int extractParagraph(CommonTree tree, StringBuilder builder, int index, int count) {
	String separator = " "; //$NON-NLS-1$
	int i;
	boolean stop = false;
	for (i = index; i < count && !stop; i++) {
	Tree child = tree.getChild(i);
	if (child.getType() != FilterParserParser.TEXT) {
	stop = true;
	continue;
	}
	builder.append(child.getText());
	builder.append(separator);
	}
	return --i;
	}

	/**
	* Generates a filter simple expression runtime object
	*
	* @return The filter simple expression
	*/
	public FilterSimpleExpression generate() {
	return new FilterSimpleExpression(fField, getConditionOperator(fOperator), fValue);
	}

	/**
	* Get the condition predicate for the operator
	*
	* @param equationType
	* The operator to convert to predicate
	* @return The condition predicate
	*/
	protected static ConditionOperator getConditionOperator(String equationType) {
	switch (equationType) {
	case IFilterStrings.EQUAL:
	return ConditionOperator.EQ;
	case IFilterStrings.NOT_EQUAL:
	return ConditionOperator.NE;
	case IFilterStrings.MATCHES:
	return ConditionOperator.MATCHES;
	case IFilterStrings.CONTAINS:
	return ConditionOperator.CONTAINS;
	case IFilterStrings.PRESENT:
	return ConditionOperator.PRESENT;
	case IFilterStrings.GT:
	return ConditionOperator.GT;
	case IFilterStrings.LT:
	return ConditionOperator.LT;
	default:
	throw new IllegalArgumentException("FilterSimpleExpression: invalid comparison operator."); //$NON-NLS-1$
	}
	}

	/**
	* Condition operators used to compare 2 values together. The first value
	* should be the internal value and the second value the value entered by
	* the user or filter.
	*/
	protected enum ConditionOperator implements BiPredicate<Object, Object> {
	/** equal */
	EQ((i, j) -> equals(i, j)),
	/** not equal */
	NE((i, j) -> !equals(i, j)),
	/** Matches */
	MATCHES(matchFunc()),
	/** Contains */
	CONTAINS((i, j) -> String.valueOf(i).contains(String.valueOf(j))),
	/** Less than */
	LT((i, j) -> numericalCompare(i, j) < 0),
	/** Greater than */
	GT((i, j) -> numericalCompare(i, j) > 0),
	/** Field is present */
	PRESENT((i, j) -> true);

	private final BiFunction<Object, Object, Boolean> fCmpFunction;

	ConditionOperator(BiFunction<Object, Object, Boolean> cmpFunction) {
	fCmpFunction = cmpFunction;
	}

	private static BiFunction<Object, Object, Boolean> matchFunc() {
	return (i, j) -> {
	Pattern filterPattern = null;
	Object value = j;
	if (j instanceof Pair) {
	Pair<?, ?> pair = (Pair<?, ?>) j;
	if (pair.getFirst() instanceof Pattern) {
	filterPattern = (Pattern) pair.getFirst();
	}
	value = pair.getSecond();
	}
	/*
	* 'value' is the value entered by the user, if it has been
	* converted to a Number, the equality check is better suited as
	* the format (hex, decimal) is considered
	*/
	if (value instanceof Number && equals(i, value)) {
	return true;
	}
	if (filterPattern != null) {
	return filterPattern.matcher(String.valueOf(i)).find();
	}
	return false;
	};
	}

	private static boolean equals(Object i, Object j) {
	// Are objects equal
	if (Objects.equals(i, j)) {
	return true;
	}
	// Are their String representation equals
	if (Objects.equals(String.valueOf(i), String.valueOf(j))) {
	return true;
	}
	// Try to convert them to number and see if they are the same
	Number number1 = toNumber(i);
	if (number1 == null) {
	return false;
	}
	Number number2 = toNumber(j);
	if (number2 == null) {
	return false;
	}
	if (number1 instanceof Double \|\| number2 instanceof Double
	\|\| number1 instanceof Float \|\| number2 instanceof Float) {
	return number1.doubleValue() == number2.doubleValue();
	}
	return number1.longValue() == number2.longValue();
	}

	private static int numericalCompare(Object i, Object j) {
	Number number1 = toNumber(i);
	Number number2 = toNumber(j);
	if (number2 == null \|\| number1 == null) {
	// Compare their string representation
	return String.valueOf(i).compareTo(String.valueOf(j));
	} else if (number1 instanceof Double \|\| number2 instanceof Double
	\|\| number1 instanceof Float \|\| number2 instanceof Float) {
	return Double.compare(number1.doubleValue(), number2.doubleValue());
	}
	return Long.compare(number1.longValue(), number2.longValue());
	}

	private static @Nullable Number toNumber(Object value) {
	if (value instanceof Number) {
	return (Number) value;
	}
	String val = String.valueOf(value);
	try {
	return Long.decode(val);
	} catch (NumberFormatException e) {
	}

	// Try to use some formatters to parse the value
	ParsePosition pos = new ParsePosition(0);
	Number parsed = NumberFormat.getInstance().parse(val, pos);
	// The full string should have been parsed, not just the first
	// numerical characters
	if (pos.getErrorIndex() < 0 && pos.getIndex() == val.length()) {
	return parsed;
	}

	// Try the decimal with unit formatter
	pos = new ParsePosition(0);
	Object parsedObj = DECIMAL_FORMAT.parseObject(val, pos);
	// The full string should have been parsed, not just the first
	// numerical characters
	if (pos.getErrorIndex() < 0 && pos.getIndex() == val.length() && parsedObj instanceof Number) {
	return (Number) parsedObj;
	}

	// Try the duration formatter
	pos = new ParsePosition(0);
	parsedObj = SubSecondTimeWithUnitFormat.getInstance().parseObject(val, pos);
	// The full string should have been parsed, not just the first
	// numerical characters
	if (pos.getErrorIndex() < 0 && pos.getIndex() == val.length() && parsedObj instanceof Number) {
	return (Number) parsedObj;
	}

	// Try the timestamp formatter
	try {
	return TmfTimestampFormat.getDefaulTimeFormat().parseValue(val);
	} catch (ParseException e) {
	// Nothing to do
	}

	return null;
	}

	@Override
	public boolean test(Object arg0, Object arg1) {
	return Objects.requireNonNull(fCmpFunction.apply(arg0, arg1));
	}

	/**
	* Convert a human-readable string value to its machine representation.
	* For example, duration strings such as "200ms" can be converted to the
	* long value of 200000000. For the MATCHES operator, return a pair that
	* contains the compiled pattern and the parsed value.
	*
	* @param operator
	* The operator for which the value is prepared
	* @param value
	* The human-readable string value entered by the user
	* @return The parsed value as a number if available, or the string
	* itself if no formatter succeeded, or a pair of the compiled
	* pattern and the parsed value.
	*/
	public static @Nullable Object prepareValue(ConditionOperator operator, @Nullable String value) {
	if (value == null) {
	return null;
	}
	Object parsedValue = value;
	// Try to convert to a number
	Number number = toNumber(value);
	if (number != null) {
	parsedValue = number;
	}
	Pattern pattern = null;
	if (operator == ConditionOperator.MATCHES) {
	// Try to compile to a pattern
	try {
	pattern = Pattern.compile(String.valueOf(value));
	} catch (PatternSyntaxException e) {
	// Ignore
	}
	if (pattern != null) {
	return new Pair<>(pattern, parsedValue);
	}
	}
	return parsedValue;
	}
	}

	@Override
	public ITmfFilterTreeNode getEventFilter(ITmfTrace trace) {
	if (fField.equals(IFilterStrings.WILDCARD)) {
	// Make a OR on all aspects
	TmfFilterOrNode orNode = new TmfFilterOrNode(null);
	for (ITmfEventAspect<?> aspect : trace.getEventAspects()) {
	TmfFilterMatchesNode node = new TmfFilterMatchesNode(null);
	node.setEventAspect(aspect);
	node.setRegex(fValue);
	orNode.addChild(node);
	}
	orNode.setNot(getNot());
	return orNode;
	}
	// Find an event aspect corresponding to the field
	ITmfEventAspect<?> filterAspect = null;
	for (ITmfEventAspect<?> aspect : trace.getEventAspects()) {
	if (aspect.getName().equals(fField)) {
	filterAspect = aspect;
	break;
	}
	}
	if (filterAspect == null) {
	// Fallback to a field aspect
	filterAspect = TmfBaseAspects.getContentsAspect().forField(fField);
	}
	TmfFilterAspectNode conditionNode = createConditionNode();
	conditionNode.setEventAspect(filterAspect);

	return conditionNode;
	}

	private TmfFilterAspectNode createConditionNode() {
	switch (fOperator) {
	case IFilterStrings.EQUAL:
	TmfFilterEqualsNode equalsNode = new TmfFilterEqualsNode(null);
	equalsNode.setValue(fValue);
	equalsNode.setNot(getNot());
	return equalsNode;
	case IFilterStrings.NOT_EQUAL:
	TmfFilterEqualsNode notEqualsNode = new TmfFilterEqualsNode(null);
	notEqualsNode.setValue(fValue);
	notEqualsNode.setNot(!getNot());
	return notEqualsNode;
	case IFilterStrings.MATCHES:
	TmfFilterMatchesNode matchesNode = new TmfFilterMatchesNode(null);
	matchesNode.setRegex(fValue);
	matchesNode.setNot(getNot());
	return matchesNode;
	case IFilterStrings.CONTAINS:
	TmfFilterContainsNode containsNode = new TmfFilterContainsNode(null);
	containsNode.setValue(fValue);
	containsNode.setNot(getNot());
	return containsNode;
	case IFilterStrings.PRESENT:
	TmfFilterMatchesNode presentNode = new TmfFilterMatchesNode(null);
	presentNode.setRegex(".*"); //$NON-NLS-1$
	presentNode.setNot(getNot());
	return presentNode;
	case IFilterStrings.GT:
	TmfFilterCompareNode gtNode = new TmfFilterCompareNode(null);
	gtNode.setResult(1);
	gtNode.setValue(fValue);
	gtNode.setNot(getNot());
	return gtNode;
	case IFilterStrings.LT:
	TmfFilterCompareNode ltNode = new TmfFilterCompareNode(null);
	ltNode.setResult(-1);
	ltNode.setValue(fValue);
	ltNode.setNot(getNot());
	return ltNode;
	default:
	throw new IllegalArgumentException("FilterSimpleExpression: invalid comparison operator."); //$NON-NLS-1$
	}
	}

	/**
	* Get whether this Cu expression is a negation
	*
	* @return <code>true</code> if the expression is a negation
	*/
	protected boolean getNot() {
	return false;
	}

	}