org.elasticsearch.index.query.RegexpFlag Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of elasticsearch Show documentation
Elasticsearch subproject :distribution:archives:integ-test-zip
There is a newer version: 8.13.4
/*
 * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
 * or more contributor license agreements. Licensed under the Elastic License
 * 2.0 and the Server Side Public License, v 1; you may not use this file except
 * in compliance with, at your election, the Elastic License 2.0 or the Server
 * Side Public License, v 1.
 */
package org.elasticsearch.index.query;

import org.apache.lucene.util.automaton.RegExp;
import org.elasticsearch.common.Strings;

import java.util.Locale;

/**
 * Regular expression syntax flags. Each flag represents optional syntax support in the regular expression:
 * 
 *     {@code INTERSECTION} - Support for intersection notation: {@code <expression> & <expression>}
 *     {@code COMPLEMENT} - Support for complement notation: {@code <expression> & <expression>}
 *     {@code EMPTY} - Support for the empty language symbol: {@code #}
 *     {@code ANYSTRING} - Support for the any string symbol: {@code @}
 *     {@code INTERVAL} - Support for numerical interval notation: {@code <n-m>}
 *     {@code NONE} - Disable support for all syntax options
 *     {@code ALL} - Enables support for all syntax options
 * 
 *
 * @see RegexpQueryBuilder#flags(RegexpFlag...)
 * @see RegexpQueryBuilder#flags(RegexpFlag...)
 */
public enum RegexpFlag {

    /**
     * Enables intersection of the form: {@code <expression> & <expression>}
     */
    INTERSECTION(RegExp.INTERSECTION),

    /**
     * Enables complement expression of the form: {@code ~<expression>}
     */
    COMPLEMENT(RegExp.COMPLEMENT),

    /**
     * Enables empty language expression: {@code #}
     */
    EMPTY(RegExp.EMPTY),

    /**
     * Enables any string expression: {@code @}
     */
    ANYSTRING(RegExp.ANYSTRING),

    /**
     * Enables numerical interval expression: {@code <n-m>}
     */
    INTERVAL(RegExp.INTERVAL),

    /**
     * Disables all available option flags
     */
    NONE(RegExp.NONE),

    /**
     * Enables all available option flags
     */
    ALL(RegExp.ALL);

    final int value;

    RegexpFlag(int value) {
        this.value = value;
    }

    public int value() {
        return value;
    }

    /**
     * Resolves the combined OR'ed value for the given list of regular expression flags. The given flags must follow the
     * following syntax:
     * 
     * {@code flag_name}(|{@code flag_name})*
     * 

     * Where {@code flag_name} is one of the following:
     * 

     *     INTERSECTION
     *     COMPLEMENT
     *     EMPTY
     *     ANYSTRING
     *     INTERVAL
     *     NONE
     *     ALL
     * 
     * 
     * Example: {@code INTERSECTION|COMPLEMENT|EMPTY}
     *
     * @param flags A string representing a list of regular expression flags
     * @return The combined OR'ed value for all the flags
     */
    public static int resolveValue(String flags) {
        if (flags == null || flags.isEmpty()) {
            return RegExp.ALL;
        }
        int magic = RegExp.NONE;
        for (String s : Strings.delimitedListToStringArray(flags, "|")) {
            if (s.isEmpty()) {
                continue;
            }
            try {
                RegexpFlag flag = RegexpFlag.valueOf(s.toUpperCase(Locale.ROOT));
                if (flag == RegexpFlag.NONE) {
                    continue;
                }
                if (flag == RegexpFlag.ALL) {
                    return flag.value();
                }
                magic |= flag.value();
            } catch (IllegalArgumentException iae) {
                throw new IllegalArgumentException("Unknown regexp flag [" + s + "]");
            }
        }
        return magic;
    }
}