// Path: src/main/java/org/hildan/fx/bindings/rulesets/Matcher.java
// public interface Matcher<T> extends Predicate<T> {
// 
//     default Binding<Boolean> matches(ObservableValue<T> observableValue) {
//         return Bindings.createBooleanBinding(() -> test(observableValue.getValue()), observableValue);
//     }
// 
// }
// 
// Path: src/main/java/org/hildan/fxlog/data/LogEntry.java
// public class LogEntry {
// 
//     private final Map<String, String> columnValues;
// 
//     private final String initialLog;
// 
//     /**
//      * Creates a new log entry with the given values for each column.
//      *
//      * @param columnValues
//      *         the values for each column. The keys are the names of the capturing groups corresponding to the columns,
//      *         and the values are the content of each column for this log.
//      * @param rawLine
//      *         the initial raw log line before being parsed into these columns. This allows later raw filtering.
//      */
//     public LogEntry(Map<String, String> columnValues, String rawLine) {
//         this.columnValues = columnValues;
//         this.initialLog = rawLine;
//     }
// 
//     /**
//      * Gets this log's content for each column. The keys are the names of the capturing groups corresponding to the
//      * columns, and the values are the contents of each column for this log.
//      *
//      * @return this log's content for each column
//      */
//     public Map<String, String> getColumnValues() {
//         return columnValues;
//     }
// 
//     /**
//      * Gets collection of this log's column values for the currently visible columns.
//      *
//      * @param columnDefinitions
//      *         the column definitions of this logs, to be able to give the values in proper order
//      *
//      * @return a collection of this log's column values for the currently visible columns
//      */
//     public List<String> getVisibleColumnValues(List<ColumnDefinition> columnDefinitions) {
//         return columnDefinitions.stream()
//                 .filter(ColumnDefinition::isVisible)
//                 .map(ColumnDefinition::getCapturingGroupName)
//                 .map(col -> getColumnValues().get(col))
//                 .collect(Collectors.toList());
//     }
// 
//     /**
//      * Gets the initial raw log line before being parsed into columns.
//      *
//      * @return the raw log line
//      */
//     public String rawLine() {
//         return initialLog;
//     }
// 
//     /**
//      * Gets a string representation of this log's column values.
//      *
//      * @param columnDefinitions
//      *         the column definitions of this logs, to be able to give the values in proper order
//      * @param delimiter
//      *         the delimiter to place between the columns in the resulting string
//      *
//      * @return a string this log's column values separated by the given delimiter
//      */
//     public String toColumnizedString(List<ColumnDefinition> columnDefinitions, CharSequence delimiter) {
//         return getVisibleColumnValues(columnDefinitions).stream().collect(Collectors.joining(delimiter));
//     }
// 
//     @Override
//     public String toString() {
//         return rawLine();
//     }
// }


import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
import javafx.beans.binding.Binding;
import javafx.beans.binding.Bindings;
import javafx.beans.property.Property;
import javafx.beans.property.SimpleObjectProperty;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
import javafx.beans.value.ObservableValue;
import org.hildan.fx.bindings.rulesets.Matcher;
import org.hildan.fxlog.data.LogEntry;
import org.intellij.lang.annotations.RegExp;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
     * @param regex
     *         the regex that the whole value of the given column should match
     *
     * @throws PatternSyntaxException
     *         if the given regex is not well formed
     */
    @NotNull
    public static Filter findInColumn(@NotNull String columnName, @NotNull @RegExp String regex) throws
            PatternSyntaxException {
        return findInColumn(columnName, regex, 0);
    }

    /**
     * Creates a new filter which applies on the value of the given column.
     *
     * @param columnName
     *         the capturing group name corresponding to the column to apply this filter to
     * @param regex
     *         the regex that the whole value of the given column should match
     * @param flags
     *         the match flags, a bit mask that may include {@link Pattern#CASE_INSENSITIVE}, {@link Pattern#MULTILINE},
     *         {@link Pattern#DOTALL}, {@link Pattern#UNICODE_CASE}, {@link Pattern#CANON_EQ}, {@link
     *         Pattern#UNIX_LINES}, {@link Pattern#LITERAL}, {@link Pattern#UNICODE_CHARACTER_CLASS} and {@link
     *         Pattern#COMMENTS}
     *
     * @throws PatternSyntaxException
     *         if the given regex is not well formed
     */
    @NotNull
    private static Filter findInColumn(@NotNull String columnName, @NotNull @RegExp String regex, int flags) throws
// Path: src/main/java/org/hildan/fx/bindings/rulesets/Matcher.java
// public interface Matcher<T> extends Predicate<T> {
// 
//     default Binding<Boolean> matches(ObservableValue<T> observableValue) {
//         return Bindings.createBooleanBinding(() -> test(observableValue.getValue()), observableValue);
//     }
// 
// }
// 
// Path: src/main/java/org/hildan/fxlog/data/LogEntry.java
// public class LogEntry {
// 
//     private final Map<String, String> columnValues;
// 
//     private final String initialLog;
// 
//     /**
//      * Creates a new log entry with the given values for each column.
//      *
//      * @param columnValues
//      *         the values for each column. The keys are the names of the capturing groups corresponding to the columns,
//      *         and the values are the content of each column for this log.
//      * @param rawLine
//      *         the initial raw log line before being parsed into these columns. This allows later raw filtering.
//      */
//     public LogEntry(Map<String, String> columnValues, String rawLine) {
//         this.columnValues = columnValues;
//         this.initialLog = rawLine;
//     }
// 
//     /**
//      * Gets this log's content for each column. The keys are the names of the capturing groups corresponding to the
//      * columns, and the values are the contents of each column for this log.
//      *
//      * @return this log's content for each column
//      */
//     public Map<String, String> getColumnValues() {
//         return columnValues;
//     }
// 
//     /**
//      * Gets collection of this log's column values for the currently visible columns.
//      *
//      * @param columnDefinitions
//      *         the column definitions of this logs, to be able to give the values in proper order
//      *
//      * @return a collection of this log's column values for the currently visible columns
//      */
//     public List<String> getVisibleColumnValues(List<ColumnDefinition> columnDefinitions) {
//         return columnDefinitions.stream()
//                 .filter(ColumnDefinition::isVisible)
//                 .map(ColumnDefinition::getCapturingGroupName)
//                 .map(col -> getColumnValues().get(col))
//                 .collect(Collectors.toList());
//     }
// 
//     /**
//      * Gets the initial raw log line before being parsed into columns.
//      *
//      * @return the raw log line
//      */
//     public String rawLine() {
//         return initialLog;
//     }
// 
//     /**
//      * Gets a string representation of this log's column values.
//      *
//      * @param columnDefinitions
//      *         the column definitions of this logs, to be able to give the values in proper order
//      * @param delimiter
//      *         the delimiter to place between the columns in the resulting string
//      *
//      * @return a string this log's column values separated by the given delimiter
//      */
//     public String toColumnizedString(List<ColumnDefinition> columnDefinitions, CharSequence delimiter) {
//         return getVisibleColumnValues(columnDefinitions).stream().collect(Collectors.joining(delimiter));
//     }
// 
//     @Override
//     public String toString() {
//         return rawLine();
//     }
// }


// Path: src/main/java/org/hildan/fxlog/filtering/Filter.java
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
import javafx.beans.binding.Binding;
import javafx.beans.binding.Bindings;
import javafx.beans.property.Property;
import javafx.beans.property.SimpleObjectProperty;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
import javafx.beans.value.ObservableValue;
import org.hildan.fx.bindings.rulesets.Matcher;
import org.hildan.fxlog.data.LogEntry;
import org.intellij.lang.annotations.RegExp;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

     * @param regex
     *         the regex that the whole value of the given column should match
     *
     * @throws PatternSyntaxException
     *         if the given regex is not well formed
     */
    @NotNull
    public static Filter findInColumn(@NotNull String columnName, @NotNull @RegExp String regex) throws
            PatternSyntaxException {
        return findInColumn(columnName, regex, 0);
    }

    /**
     * Creates a new filter which applies on the value of the given column.
     *
     * @param columnName
     *         the capturing group name corresponding to the column to apply this filter to
     * @param regex
     *         the regex that the whole value of the given column should match
     * @param flags
     *         the match flags, a bit mask that may include {@link Pattern#CASE_INSENSITIVE}, {@link Pattern#MULTILINE},
     *         {@link Pattern#DOTALL}, {@link Pattern#UNICODE_CASE}, {@link Pattern#CANON_EQ}, {@link
     *         Pattern#UNIX_LINES}, {@link Pattern#LITERAL}, {@link Pattern#UNICODE_CHARACTER_CLASS} and {@link
     *         Pattern#COMMENTS}
     *
     * @throws PatternSyntaxException
     *         if the given regex is not well formed
     */
    @NotNull
    private static Filter findInColumn(@NotNull String columnName, @NotNull @RegExp String regex, int flags) throws
            PatternSyntaxException {