Runtime

## org.eclipse.gmf.runtime.common.core.util
Class StringMatcher

    java.lang.Object
      org.eclipse.gmf.runtime.common.core.util.StringMatcher

    public class StringMatcher

extends java.lang.Object

A string pattern matcher, supporting wildcard characters. This class is cloned from org.eclipse.ui.internal.misc.StringMatcher

Nested Class Summary
`static class` `StringMatcher.Position` Keeps track of the internal position of the matcher.

Field Summary
`protected int` `fBound` Boundary value beyond which we don't need to search in the text
`protected boolean` `fHasLeadingStar` Has a leading wildcard
`protected boolean` `fHasTrailingStar` Has a trailing wildcard
`protected boolean` `fIgnoreCase` Ignore case
`protected boolean` `fIgnoreWildCards` Ignore wildcards
`protected int` `fLength` The pattern length
`protected java.lang.String` `fPattern` The pattern
`protected java.lang.String[]` `fSegments` The given pattern is split into * separated segments
`protected static char` `fSingleWildCard` The single wildcard character

Constructor Summary
`StringMatcher(java.lang.String pattern, boolean ignoreCase, boolean ignoreWildCards)` StringMatcher constructor takes in a String object that is a simple pattern which may contain `'*'` for 0 or more characters and `'?'`

Method Summary
`StringMatcher.Position` `find(java.lang.String text, int start, int end)` Find the first occurrence of the pattern between `start</code)(inclusive) and <code>end`(exclusive).
`boolean` `match(java.lang.String text)` match the given `text` with the pattern
`boolean` `match(java.lang.String text, int start, int end)` Given the starting (inclusive) and the ending (exclusive) positions in the `text`, determine if the given substring matches with aPattern
`protected int` `posIn(java.lang.String text, int start, int end)`
`protected int` `regExpPosIn(java.lang.String text, int start, int end, java.lang.String p)` Return the position of regulat expression in specified string.
`protected boolean` `regExpRegionMatches(java.lang.String text, int tStart, java.lang.String p, int pStart, int plen)` Check if the specified regular expression matches string.
`protected int` `textPosIn(java.lang.String text, int start, int end, java.lang.String p)`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### fPattern

    protected java.lang.String fPattern

  The pattern

### fLength

    protected int fLength

  The pattern length

### fIgnoreWildCards

    protected boolean fIgnoreWildCards

  Ignore wildcards

### fIgnoreCase

    protected boolean fIgnoreCase

  Ignore case

### fHasLeadingStar

    protected boolean fHasLeadingStar

  Has a leading wildcard

### fHasTrailingStar

    protected boolean fHasTrailingStar

  Has a trailing wildcard

### fSegments

    protected java.lang.String[] fSegments

  The given pattern is split into * separated segments

### fBound

    protected int fBound

  Boundary value beyond which we don't need to search in the text

### fSingleWildCard

    protected static final char fSingleWildCard

  The single wildcard character

  See Also:
    Constant Field Values

Constructor Detail

### StringMatcher

    public StringMatcher(java.lang.String pattern,
                         boolean ignoreCase,
                         boolean ignoreWildCards)

  StringMatcher constructor takes in a String object that is a simple pattern which may contain `'*'` for 0 or more characters and `'?'` for exactly one character. Literal characters must be escaped in the pattern e.g., `"\*"` means literal `"*"`, etc. Escaping any other character (including the escape character itself), just results in that character in the pattern. e.g., `"\a"` means `"a"` and `"\\"` means `"\"` If invoking the StringMatcher with string literals in Java, don't forget escape characters are represented by `"\\"`.

  Parameters:
    `pattern` - the pattern to match text against
    `ignoreCase` - if true, case is ignored
    `ignoreWildCards` - if true, wild cards and their escape sequences are ignored (everything is taken literally).

Method Detail

### find

    public StringMatcher.Position find(java.lang.String text,
                                       int start,
                                       int end)

  Find the first occurrence of the pattern between `start</code)(inclusive) and <code>end`(exclusive).

  Parameters:
    `text` - `String` the String object to search in
    `start` - `int`, the starting index of the search range, inclusive
    `end` - `int`, the ending index of the search range, exclusive
  Returns:
    an `StringMatcher.Position` object that keeps the starting (inclusive) and ending positions (exclusive) of the first occurrence of the pattern in the specified range of the text; return null if not found or subtext is empty (start==end). A pair of zeros is returned if pattern is empty string Note that for pattern like "*abc*" with leading and trailing stars, position of "abc" is returned. For a pattern like"*??*" in text "abcdf", (1,3) is returned

### match

    public boolean match(java.lang.String text)

  match the given `text` with the pattern

  Parameters:
    `text` - `String`, a String object
  Returns:
    true if matched eitherwise false

### match

    public boolean match(java.lang.String text,
                         int start,
                         int end)

  Given the starting (inclusive) and the ending (exclusive) positions in the `text`, determine if the given substring matches with aPattern

  Parameters:
    `text` - `String` a String object that contains the substring to match
    `start` - `int` marks the starting position (inclusive) of the substring
    `end` - `int` marks the ending index (exclusive) of the substring
  Returns:
    true if the specified portion of the text matches the pattern

### posIn

    protected int posIn(java.lang.String text,
                        int start,
                        int end)

  Parameters:
    `text` - a string which contains no wildcard
    `start` - the starting index in the text for search, inclusive
    `end` - the stopping point of search, exclusive
  Returns:
    the starting index in the text of the pattern , or -1 if not found

### regExpPosIn

    protected int regExpPosIn(java.lang.String text,
                              int start,
                              int end,
                              java.lang.String p)

  Return the position of regulat expression in specified string.

  Parameters:
    `text` - a simple regular expression that may only contain '?'(s)
    `start` - the starting index in the text for search, inclusive
    `end` - the stopping point of search, exclusive
    `p` - a simple regular expression that may contains '?'
  Returns:
    the starting index in the text of the pattern , or -1 if not found

### regExpRegionMatches

    protected boolean regExpRegionMatches(java.lang.String text,
                                          int tStart,
                                          java.lang.String p,
                                          int pStart,
                                          int plen)

  Check if the specified regular expression matches string.

  Parameters:
    `text` - a simple regular expression
    `tStart` - the starting index in the text for search, inclusive
    `p` - a simple regular expression that may contains '?'
    `pStart` -
    `plen` -
  Returns:
    true if reular expression matches, false otherwise

### textPosIn

    protected int textPosIn(java.lang.String text,
                            int start,
                            int end,
                            java.lang.String p)

  Parameters:
    `text` - the string to match
    `start` - the starting index in the text for search, inclusive
    `end` - the stopping point of search, exclusive
    `p` - a string that has no wildcard
  Returns:
    the starting index in the text of the pattern , or -1 if not found

Runtime

Guidelines for using Eclipse APIs.

Copyright (c) IBM Corp., Borland Software Corp., and others 2005,2006. All rights reserved.