Class TransliterationRule

java.lang.Object
com.ibm.icu.text.TransliterationRule

class TransliterationRule extends Object
A transliteration rule used by RuleBasedTransliterator. TransliterationRule is an immutable object.

A rule consists of an input pattern and an output string. When the input pattern is matched, the output string is emitted. The input pattern consists of zero or more characters which are matched exactly (the key) and optional context. Context must match if it is specified. Context may be specified before the key, after the key, or both. The key, preceding context, and following context may contain variables. Variables represent a set of Unicode characters, such as the letters a through z. Variables are detected by looking up each character in a supplied variable list to see if it has been so defined.

A rule may contain segments in its input string and segment references in its output string. A segment is a substring of the input pattern, indicated by an offset and limit. The segment may be in the preceding or following context. It may not span a context boundary. A segment reference is a special character in the output string that causes a segment of the input string (not the input pattern) to be copied to the output string. The range of special characters that represent segment references is defined by RuleBasedTransliterator.Data.

Example: The rule "([a-z]) . ([0-9]) > $2 . $1" will change the input string "abc.123" to "ab1.c23".

Copyright © IBM Corporation 1999. All rights reserved.

  • Field Details

    • anteContext

      private StringMatcher anteContext
      The match that must occur before the key, or null if there is no preceding context.
    • key

      private StringMatcher key
      The matcher object for the key. If null, then the key is empty.
    • postContext

      private StringMatcher postContext
      The match that must occur after the key, or null if there is no following context.
    • output

      private UnicodeReplacer output
      The object that performs the replacement if the key, anteContext, and postContext are matched. Never null.
    • pattern

      private String pattern
      The string that must be matched, consisting of the anteContext, key, and postContext, concatenated together, in that order. Some components may be empty (zero length).
      See Also:
    • segments

      UnicodeMatcher[] segments
      An array of matcher objects corresponding to the input pattern segments. If there are no segments this is null. N.B. This is a UnicodeMatcher for generality, but in practice it is always a StringMatcher. In the future we may generalize this, but for now we sometimes cast down to StringMatcher.
    • anteContextLength

      private int anteContextLength
      The length of the string that must match before the key. If zero, then there is no matching requirement before the key. Substring [0,anteContextLength) of pattern is the anteContext.
    • keyLength

      private int keyLength
      The length of the key. Substring [anteContextLength, anteContextLength + keyLength) is the key.
    • flags

      byte flags
      Miscellaneous attributes.
    • ANCHOR_START

      static final int ANCHOR_START
      Flag attributes.
      See Also:
    • ANCHOR_END

      static final int ANCHOR_END
      See Also:
    • data

      private final RuleBasedTransliterator.Data data
      An alias pointer to the data for this rule. The data provides lookup services for matchers and segments.
  • Constructor Details

    • TransliterationRule

      public TransliterationRule(String input, int anteContextPos, int postContextPos, String output, int cursorPos, int cursorOffset, UnicodeMatcher[] segs, boolean anchorStart, boolean anchorEnd, RuleBasedTransliterator.Data theData)
      Construct a new rule with the given input, output text, and other attributes. A cursor position may be specified for the output text.
      Parameters:
      input - input string, including key and optional ante and post context
      anteContextPos - offset into input to end of ante context, or -1 if none. Must be invalid input: '<'= input.length() if not -1.
      postContextPos - offset into input to start of post context, or -1 if none. Must be invalid input: '<'= input.length() if not -1, and must be >= anteContextPos.
      output - output string
      cursorPos - offset into output at which cursor is located, or -1 if none. If less than zero, then the cursor is placed after the output; that is, -1 is equivalent to output.length(). If greater than output.length() then an exception is thrown.
      cursorOffset - an offset to be added to cursorPos to position the cursor either in the ante context, if invalid input: '<' 0, or in the post context, if > 0. For example, the rule "abc{def} > | @@@ xyz;" changes "def" to "xyz" and moves the cursor to before "a". It would have a cursorOffset of -3.
      segs - array of UnicodeMatcher corresponding to input pattern segments, or null if there are none
      anchorStart - true if the the rule is anchored on the left to the context start
      anchorEnd - true if the rule is anchored on the right to the context limit
  • Method Details

    • getAnteContextLength

      public int getAnteContextLength()
      Return the preceding context length. This method is needed to support the Transliterator method getMaximumContextLength().
    • getIndexValue

      final int getIndexValue()
      Internal method. Returns 8-bit index value for this rule. This is the low byte of the first character of the key, unless the first character of the key is a set. If it's a set, or otherwise can match multiple keys, the index value is -1.
    • matchesIndexValue

      final boolean matchesIndexValue(int v)
      Internal method. Returns true if this rule matches the given index value. The index value is an 8-bit integer, 0..255, representing the low byte of the first character of the key. It matches this rule if it matches the first character of the key, or if the first character of the key is a set, and the set contains any character with a low byte equal to the index value. If the rule contains only ante context, as in foo)>bar, then it will match any key.
    • masks

      public boolean masks(TransliterationRule r2)
      Return true if this rule masks another rule. If r1 masks r2 then r1 matches any input string that r2 matches. If r1 masks r2 and r2 masks r1 then r1 == r2. Examples: "a>x" masks "ab>y". "a>x" masks "a[b]>y". "[c]a>x" masks "[dc]a>y".
    • posBefore

      static final int posBefore(Replaceable str, int pos)
    • posAfter

      static final int posAfter(Replaceable str, int pos)
    • matchAndReplace

      public int matchAndReplace(Replaceable text, Transliterator.Position pos, boolean incremental)
      Attempt a match and replacement at the given position. Return the degree of match between this rule and the given text. The degree of match may be mismatch, a partial match, or a full match. A mismatch means at least one character of the text does not match the context or key. A partial match means some context and key characters match, but the text is not long enough to match all of them. A full match means all context and key characters match. If a full match is obtained, perform a replacement, update pos, and return U_MATCH. Otherwise both text and pos are unchanged.
      Parameters:
      text - the text
      pos - the position indices
      incremental - if true, test for partial matches that may be completed by additional text inserted at pos.limit.
      Returns:
      one of U_MISMATCH, U_PARTIAL_MATCH, or U_MATCH. If incremental is false then U_PARTIAL_MATCH will not be returned.
    • toRule

      public String toRule(boolean escapeUnprintable)
      Create a source string that represents this rule. Append it to the given string.
    • toString

      public String toString()
      Return a string representation of this object.
      Overrides:
      toString in class Object
      Returns:
      string representation of this object
    • addSourceTargetSet

      void addSourceTargetSet(UnicodeSet filter, UnicodeSet sourceSet, UnicodeSet targetSet, UnicodeSet revisiting)
      Find the source and target sets, subject to the input filter. There is a known issue with filters containing multiple characters.