Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2009 The Guava Authors
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package com.google.common.escape;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 
 import java.util.Map;
 
A UnicodeEscaper that uses an array to quickly look up replacement characters for a given code point. An additional safe range is provided that determines whether code points without specific replacements are to be considered safe and left unescaped or should be escaped in a general way.

A good example of usage of this class is for HTML escaping where the replacement array contains information about the named HTML entities such as & and " while escapeUnsafe(int) is overridden to handle general escaping of the form &#NNNNN;.

The size of the data structure used by ArrayBasedUnicodeEscaper is proportional to the highest valued code point that requires escaping. For example a replacement map containing the single character '\u1000' will require approximately 16K of memory. If you need to create multiple escaper instances that have the same character replacement mapping consider using ArrayBasedEscaperMap.

Author(s):
David Beaumont
Since:
15.0
 
 public abstract class ArrayBasedUnicodeEscaper extends UnicodeEscaper {
   // The replacement array (see ArrayBasedEscaperMap).
   private final char[][] replacements;
   // The number of elements in the replacement array.
   private final int replacementsLength;
   // The first code point in the safe range.
   private final int safeMin;
   // The last code point in the safe range.
   private final int safeMax;
 
   // Cropped values used in the fast path range checks.
   private final char safeMinChar;
   private final char safeMaxChar;

  
Creates a new ArrayBasedUnicodeEscaper instance with the given replacement map and specified safe range. If safeMax < safeMin then no code points are considered safe.

If a code point has no mapped replacement then it is checked against the safe range. If it lies outside that, then escapeUnsafe(int) is called, otherwise no escaping is performed.

Parameters:
replacementMap a map of characters to their escaped representations
safeMin the lowest character value in the safe range
safeMax the highest character value in the safe range
unsafeReplacement the default replacement for unsafe characters or null if no default replacement is required
 
   protected ArrayBasedUnicodeEscaper(Map<CharacterStringreplacementMap,
       int safeMinint safeMax, @Nullable String unsafeReplacement) {
 
     this(ArrayBasedEscaperMap.create(replacementMap), safeMinsafeMax,
         unsafeReplacement);
   }

  
Creates a new ArrayBasedUnicodeEscaper instance with the given replacement map and specified safe range. If safeMax < safeMin then no code points are considered safe. This initializer is useful when explicit instances of ArrayBasedEscaperMap are used to allow the sharing of large replacement mappings.

If a code point has no mapped replacement then it is checked against the safe range. If it lies outside that, then escapeUnsafe(int) is called, otherwise no escaping is performed.

Parameters:
escaperMap the map of replacements
safeMin the lowest character value in the safe range
safeMax the highest character value in the safe range
unsafeReplacement the default replacement for unsafe characters or null if no default replacement is required
      int safeMinint safeMax, @Nullable String unsafeReplacement) {
    checkNotNull(escaperMap);  // GWT specific check (do not optimize)
    this. = escaperMap.getReplacementArray();
    if (safeMax < safeMin) {
      // If the safe range is empty, set the range limits to opposite extremes
      // to ensure the first test of either value will fail.
      safeMax = -1;
      safeMin = .;
    }
    this. = safeMin;
    this. = safeMax;
    // This is a bit of a hack but lets us do quicker per-character checks in
    // the fast path code. The safe min/max values are very unlikely to extend
    // into the range of surrogate characters, but if they do we must not test
    // any values in that range. To see why, consider the case where:
    //   safeMin <= {hi,lo} <= safeMax
    // where {hi,lo} are characters forming a surrogate pair such that:
    //   codePointOf(hi, lo) > safeMax
    // which would result in the surrogate pair being (wrongly) considered safe.
    // If we clip the safe range used during the per-character tests so it is
    // below the values of characters in surrogate pairs, this cannot occur.
    // This approach does mean that we break out of the fast path code in cases
    // where we don't strictly need to, but this situation will almost never
    // occur in practice.
    if (safeMin >= .) {
      // The safe range is empty or the all safe code points lie in or above the
      // surrogate range. Either way the character range is empty.
      this. = .;
      this. = 0;
    } else {
      // The safe range is non empty and contains values below the surrogate
      // range but may extend above it. We may need to clip the maximum value.
      this. = (charsafeMin;
      this. = (char) Math.min(safeMax,
                                         . - 1);
    }
  }
  /*
   * This is overridden to improve performance. Rough benchmarking shows that
   * this almost doubles the speed when processing strings that do not require
   * any escaping.
   */
  public final String escape(String s) {
    checkNotNull(s);  // GWT specific check (do not optimize)
    for (int i = 0; i < s.length(); i++) {
      char c = s.charAt(i);
      if ((c <  && [c] != null) ||
          c >  || c < ) {
        return escapeSlow(si);
      }
    }
    return s;
  }
  /* Overridden for performance. */
  protected final int nextEscapeIndex(CharSequence csqint indexint end) {
    while (index < end) {
      char c = csq.charAt(index);
      if ((c <  && [c] != null) ||
          c >  || c < ) {
        break;
      }
      index++;
    }
    return index;
  }

  
Escapes a single Unicode code point using the replacement array and safe range values. If the given character does not have an explicit replacement and lies outside the safe range then escapeUnsafe(int) is called.
  protected final char[] escape(int cp) {
    if (cp < ) {
      char[] chars = [cp];
      if (chars != null) {
        return chars;
      }
    }
    if (cp >=  && cp <= ) {
      return null;
    }
    return escapeUnsafe(cp);
  }

  
Escapes a code point that has no direct explicit value in the replacement array and lies outside the stated safe range. Subclasses should override this method to provide generalized escaping for code points if required.

Note that arrays returned by this method must not be modified once they have been returned. However it is acceptable to return the same array multiple times (even for different input characters).

Parameters:
cp the Unicode code point to escape
Returns:
the replacement characters, or null if no escaping was required
  protected abstract char[] escapeUnsafe(int cp);
New to GrepCode? Check out our FAQ X