RegularExpressionPatternCompileMode.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */


  22. package org.openspcoop2.utils.regexp;


  25. import java.util.regex.Pattern;

  27. /** Enumeration contenente le modalita' di compilazione delle espressioni regolari
  28.  *
  29.  * @author Andrea Poli (apoli@link.it)
  30.  * @author $Author$
  31.  * @version $Rev$, $Date$
  32.  */

  34. public enum RegularExpressionPatternCompileMode {

  36.     /** 
  37.      * Enables canonical equivalence.
  38.      *
  39.      * When this flag is specified then two characters will be considered to match if, and only if, 
  40.      * their full canonical decompositions match. 
  41.      * The expression "a\u030A", for example, will match the string "?" when this flag is specified. 
  42.      * By default, matching does not take canonical equivalence into account.
  43.      *
  44.      * There is no embedded flag character for enabling canonical equivalence.  
  45.      *
  46.      * Specifying this flag may impose a performance penalty. 
  47.      **/
  48.     CANON_EQ(Pattern.CANON_EQ),
  49.     
  50.     /** 
  51.      * Enables case-insensitive matching.
  52.      * 
  53.      * By default, case-insensitive matching assumes that only characters in the US-ASCII charset are being matched. 
  54.      * Unicode-aware case-insensitive matching can be enabled by specifying the UNICODE_CASE flag in conjunction (or) 
  55.      * with this flag.
  56.      * 
  57.      * Case-insensitive matching can also be enabled via the embedded flag expression (?i).
  58.      * 
  59.      * Specifying this flag may impose a slight performance penalty. 
  60.      **/
  61.     CASE_INSENSITIVE(Pattern.CASE_INSENSITIVE),
  62.     
  63.     /**
  64.      * Permits whitespace and comments in pattern.
  65.      *
  66.      * In this mode, whitespace is ignored, and embedded comments starting with # are ignored until the end of a line.
  67.      *
  68.      * Comments mode can also be enabled via the embedded flag expression (?x). 
  69.      **/
  70.     COMMENTS(Pattern.COMMENTS),
  71.     
  72.     /**
  73.      * Enables dotall mode.
  74.      *
  75.      * In dotall mode, the expression . matches any character, including a line terminator. 
  76.      * By default this expression does not match line terminators.
  77.      * 
  78.      * Dotall mode can also be enabled via the embedded flag expression (?s). 
  79.      * (The s is a mnemonic for "single-line" mode, which is what this is called in Perl.) 
  80.      **/
  81.     DOTALL(Pattern.DOTALL),
  82.     
  83.     /**
  84.      * Enables literal parsing of the pattern.
  85.      *
  86.      * When this flag is specified then the input string that specifies the pattern is treated as a sequence of literal characters. 
  87.      * Metacharacters or escape sequences in the input sequence will be given no special meaning.
  88.      *
  89.      * The flags CASE_INSENSITIVE and UNICODE_CASE retain their impact on matching when used in conjunction with this flag. 
  90.      * The other flags become superfluous.
  91.      *
  92.      * There is no embedded flag character for enabling literal parsing. 
  93.      **/
  94.     LITERAL(Pattern.LITERAL),
  95.     
  96.     /**
  97.      * Enables multiline mode.
  98.      * 
  99.      * In multiline mode the expressions ^ and $ match just after or just before, respectively, 
  100.      * a line terminator or the end of the input sequence. 
  101.      * By default these expressions only match at the beginning and the end of the entire input sequence.
  102.      *
  103.      * Multiline mode can also be enabled via the embedded flag expression (?m).
  104.      **/
  105.     MULTILINE(Pattern.MULTILINE),
  106.     
  107.     /**
  108.      * Enables Unicode-aware case folding.
  109.      *
  110.      * When this flag is specified then case-insensitive matching, when enabled by the CASE_INSENSITIVE flag, 
  111.      * is done in a manner consistent with the Unicode Standard. 
  112.      * By default, case-insensitive matching assumes that only characters in the US-ASCII charset are being matched.
  113.      *
  114.      * Unicode-aware case folding can also be enabled via the embedded flag expression (?u).
  115.      *
  116.      * Specifying this flag may impose a performance penalty. 
  117.      **/
  118.     UNICODE_CASE(Pattern.UNICODE_CASE),
  119.     
  120.     /** 
  121.      * Enables Unix lines mode.
  122.      * 
  123.      * In this mode, only the '\n' line terminator is recognized in the behavior of ., ^, and $.
  124.      * 
  125.      * Unix lines mode can also be enabled via the embedded flag expression (?d).
  126.      **/
  127.     UNIX_LINES(Pattern.UNIX_LINES);
  128.     
  129.     private int value;

  131.     RegularExpressionPatternCompileMode(int value)
  132.     {
  133.         this.value = value;
  134.     }

  136.     public int getPatternCompileMode()
  137.     {
  138.         return this.value;
  139.     }
  140.     
  141.     @Override
  142.     public String toString(){
  143.         return this.name();
  144.     }
  145.     
  146.     
  147. }
Created with JaCoCo 0.8.8.202204050719