001/* 002 * Copyright (C) 2006 The Guava Authors 003 * 004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except 005 * in compliance with the License. You may obtain a copy of the License at 006 * 007 * http://www.apache.org/licenses/LICENSE-2.0 008 * 009 * Unless required by applicable law or agreed to in writing, software distributed under the License 010 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express 011 * or implied. See the License for the specific language governing permissions and limitations under 012 * the License. 013 */ 014 015package com.google.common.escape; 016 017import static com.google.common.base.Preconditions.checkNotNull; 018 019import com.google.common.annotations.Beta; 020import com.google.common.annotations.GwtCompatible; 021import com.google.errorprone.annotations.CanIgnoreReturnValue; 022import java.util.HashMap; 023import java.util.Map; 024import java.util.Map.Entry; 025 026/** 027 * Simple helper class to build a "sparse" array of objects based on the indexes that were added to 028 * it. The array will be from 0 to the maximum index given. All non-set indexes will contain null 029 * (so it's not really a sparse array, just a pseudo sparse array). The builder can also return a 030 * CharEscaper based on the generated array. 031 * 032 * @author Sven Mawson 033 * @since 15.0 034 */ 035@Beta 036@GwtCompatible 037public final class CharEscaperBuilder { 038 /** 039 * Simple decorator that turns an array of replacement char[]s into a CharEscaper, this results in 040 * a very fast escape method. 041 */ 042 private static class CharArrayDecorator extends CharEscaper { 043 private final char[][] replacements; 044 private final int replaceLength; 045 046 CharArrayDecorator(char[][] replacements) { 047 this.replacements = replacements; 048 this.replaceLength = replacements.length; 049 } 050 051 /* 052 * Overriding escape method to be slightly faster for this decorator. We test the replacements 053 * array directly, saving a method call. 054 */ 055 @Override 056 public String escape(String s) { 057 int slen = s.length(); 058 for (int index = 0; index < slen; index++) { 059 char c = s.charAt(index); 060 if (c < replacements.length && replacements[c] != null) { 061 return escapeSlow(s, index); 062 } 063 } 064 return s; 065 } 066 067 @Override 068 protected char[] escape(char c) { 069 return c < replaceLength ? replacements[c] : null; 070 } 071 } 072 073 // Replacement mappings. 074 private final Map<Character, String> map; 075 076 // The highest index we've seen so far. 077 private int max = -1; 078 079 /** Construct a new sparse array builder. */ 080 public CharEscaperBuilder() { 081 this.map = new HashMap<>(); 082 } 083 084 /** Add a new mapping from an index to an object to the escaping. */ 085 @CanIgnoreReturnValue 086 public CharEscaperBuilder addEscape(char c, String r) { 087 map.put(c, checkNotNull(r)); 088 if (c > max) { 089 max = c; 090 } 091 return this; 092 } 093 094 /** Add multiple mappings at once for a particular index. */ 095 @CanIgnoreReturnValue 096 public CharEscaperBuilder addEscapes(char[] cs, String r) { 097 checkNotNull(r); 098 for (char c : cs) { 099 addEscape(c, r); 100 } 101 return this; 102 } 103 104 /** 105 * Convert this builder into an array of char[]s where the maximum index is the value of the 106 * highest character that has been seen. The array will be sparse in the sense that any unseen 107 * index will default to null. 108 * 109 * @return a "sparse" array that holds the replacement mappings. 110 */ 111 public char[][] toArray() { 112 char[][] result = new char[max + 1][]; 113 for (Entry<Character, String> entry : map.entrySet()) { 114 result[entry.getKey()] = entry.getValue().toCharArray(); 115 } 116 return result; 117 } 118 119 /** 120 * Convert this builder into a char escaper which is just a decorator around the underlying array 121 * of replacement char[]s. 122 * 123 * @return an escaper that escapes based on the underlying array. 124 */ 125 public Escaper toEscaper() { 126 return new CharArrayDecorator(toArray()); 127 } 128}