org.apache.tiles.core.util

## Class WildcardHelper

- java.lang.Object
- - org.apache.tiles.core.util.WildcardHelper

-     public class WildcardHelper
      extends Object

  This class is an utility class that perform wilcard-patterns matching and isolation taken from Apache Struts that is taken, in turn, from Apache Struts.
  Since:
    2.1.0

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected static int` | `MATCH_BEGIN` The int representing begin in the pattern `int []`.
    `protected static int` | `MATCH_END` The int value that terminates the pattern `int []`.
    `protected static int` | `MATCH_FILE` The int representing '*' in the pattern `int []`.
    `protected static int` | `MATCH_PATH` The int representing '**' in the pattern `int []`.
    `protected static int` | `MATCH_THEEND` The int representing end in pattern `int []`.

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `WildcardHelper()`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `int[]` | `compilePattern(String data)` Translate the given `String` into a `int []` representing the pattern matchable by this class.
    `static String` | `convertParam(String val, Map<Integer,String> vars)` Inserts into a value wildcard-matched strings where specified.
    `protected int` | `indexOfArray(int[] r, int rpos, int rend, char[] d, int dpos)` Get the offset of a part of an int array within a char array.
    `protected int` | `lastIndexOfArray(int[] r, int rpos, int rend, char[] d, int dpos)` Get the offset of a last occurance of an int array within a char array.
    `List<String>` | `match(String data, int[] expr)` Match a pattern agains a string and isolates wildcard replacement into a `Stack`.
    `protected boolean` | `matchArray(int[] r, int rpos, int rend, char[] d, int dpos)` Matches elements of array r from rpos to rend with array d, starting from dpos.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### MATCH_FILE

          protected static final int MATCH_FILE

      The int representing '*' in the pattern `int []`.
      Since:
        2.1.0
      See Also:
        Constant Field Values

    - #### MATCH_PATH

          protected static final int MATCH_PATH

      The int representing '**' in the pattern `int []`.
      Since:
        2.1.0
      See Also:
        Constant Field Values

    - #### MATCH_BEGIN

          protected static final int MATCH_BEGIN

      The int representing begin in the pattern `int []`.
      Since:
        2.1.0
      See Also:
        Constant Field Values

    - #### MATCH_THEEND

          protected static final int MATCH_THEEND

      The int representing end in pattern `int []`.
      Since:
        2.1.0
      See Also:
        Constant Field Values

    - #### MATCH_END

          protected static final int MATCH_END

      The int value that terminates the pattern `int []`.
      Since:
        2.1.0
      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### WildcardHelper

          public WildcardHelper()

  - ### Method Detail

    - #### compilePattern

          public int[] compilePattern(String data)

      Translate the given `String` into a `int []` representing the pattern matchable by this class.
      This function translates a `String` into an int array converting the special '*' and '\' characters.
      Here is how the conversion algorithm works:

      - The '*' character is converted to MATCH_FILE, meaning that zero or more characters (excluding the path separator '/') are to be matched.
      - The '**' sequence is converted to MATCH_PATH, meaning that zero or more characters (including the path separator '/') are to be matched.
      - The '\' character is used as an escape sequence ('\*' is translated in '*', not in MATCH_FILE). If an exact '\' character is to be matched the source string must contain a '\\'. sequence.

      When more than two '*' characters, not separated by another character, are found their value is considered as '**' (MATCH_PATH).
      The array is always terminated by a special value (MATCH_END).
      All MATCH* values are less than zero, while normal characters are equal or greater.

      Parameters:
        `data` - The string to translate.
      Returns:
        The encoded string as an int array, terminated by the MATCH_END value (don't consider the array length).
      Throws:
        `NullPointerException` - If data is null.
      Since:
        2.1.0

    - #### match

          public List<String> match(String data,
                                    int[] expr)

      Match a pattern agains a string and isolates wildcard replacement into a `Stack`.
      Parameters:
        `data` - The string to match
        `expr` - The compiled wildcard expression
      Returns:
        The list of matched variables, or `null` if it does not match.
      Throws:
        `NullPointerException` - If any parameters are null
      Since:
        2.2.0

    - #### indexOfArray

          protected int indexOfArray(int[] r,
                                     int rpos,
                                     int rend,
                                     char[] d,
                                     int dpos)

      Get the offset of a part of an int array within a char array.
      This method return the index in d of the first occurrence after dpos of that part of array specified by r, starting at rpos and terminating at rend.
      Parameters:
        `r` - The array containing the data that need to be matched in d.
        `rpos` - The index of the first character in r to look for.
        `rend` - The index of the last character in r to look for plus 1.
        `d` - The array of char that should contain a part of r.
        `dpos` - The starting offset in d for the matching.
      Returns:
        The offset in d of the part of r matched in d or -1 if that was not found.
      Since:
        2.1.0

    - #### lastIndexOfArray

          protected int lastIndexOfArray(int[] r,
                                         int rpos,
                                         int rend,
                                         char[] d,
                                         int dpos)

      Get the offset of a last occurance of an int array within a char array.
      This method return the index in d of the last occurrence after dpos of that part of array specified by r, starting at rpos and terminating at rend.
      Parameters:
        `r` - The array containing the data that need to be matched in d.
        `rpos` - The index of the first character in r to look for.
        `rend` - The index of the last character in r to look for plus 1.
        `d` - The array of char that should contain a part of r.
        `dpos` - The starting offset in d for the matching.
      Returns:
        The offset in d of the last part of r matched in d or -1 if that was not found.
      Since:
        2.1.0

    - #### matchArray

          protected boolean matchArray(int[] r,
                                       int rpos,
                                       int rend,
                                       char[] d,
                                       int dpos)

      Matches elements of array r from rpos to rend with array d, starting from dpos.
      This method return true if elements of array r from rpos to rend equals elements of array d starting from dpos to dpos+(rend-rpos).
      Parameters:
        `r` - The array containing the data that need to be matched in d.
        `rpos` - The index of the first character in r to look for.
        `rend` - The index of the last character in r to look for.
        `d` - The array of char that should start from a part of r.
        `dpos` - The starting offset in d for the matching.
      Returns:
        true if array d starts from portion of array r.
      Since:
        2.1.0

    - #### convertParam

          public static String convertParam(String val,
                                            Map<Integer,String> vars)

      Inserts into a value wildcard-matched strings where specified.

      Parameters:
        `val` - The value to convert
        `vars` - A Map of wildcard-matched strings
      Returns:
        The new value
      Since:
        2.1.0

Copyright © 2000–2024 Apache Software Foundation. All rights reserved.