/** * Creates a new ArrayBasedCharEscaper instance with the given replacement map and specified safe * range. If {@code safeMax < safeMin} then no characters are considered safe. This initializer is * useful when explicit instances of ArrayBasedEscaperMap are used to allow the sharing of large * replacement mappings. * * <p>If a character has no mapped replacement then it is checked against the safe range. If it * lies outside that, then {@link #escapeUnsafe} is called, otherwise no escaping is performed. * * @param escaperMap the mapping of characters to be escaped * @param safeMin the lowest character value in the safe range * @param safeMax the highest character value in the safe range */ protected ArrayBasedCharEscaper(ArrayBasedEscaperMap escaperMap, char safeMin, char safeMax) { checkNotNull(escaperMap); // GWT specific check (do not optimize) this.replacements = escaperMap.getReplacementArray(); this.replacementsLength = replacements.length; 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 (almost certainly) fail. safeMax = Character.MIN_VALUE; safeMin = Character.MAX_VALUE; } this.safeMin = safeMin; this.safeMax = safeMax; }
/** * Creates a new ArrayBasedCharEscaper instance with the given replacement map and specified safe * range. If {@code safeMax < safeMin} then no characters are considered safe. This initializer is * useful when explicit instances of ArrayBasedEscaperMap are used to allow the sharing of large * replacement mappings. * * <p>If a character has no mapped replacement then it is checked against the safe range. If it * lies outside that, then {@link #escapeUnsafe} is called, otherwise no escaping is performed. * * @param escaperMap the mapping of characters to be escaped * @param safeMin the lowest character value in the safe range * @param safeMax the highest character value in the safe range */ protected ArrayBasedCharEscaper(ArrayBasedEscaperMap escaperMap, char safeMin, char safeMax) { checkNotNull(escaperMap); // GWT specific check (do not optimize) this.replacements = escaperMap.getReplacementArray(); this.replacementsLength = replacements.length; 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 (almost certainly) fail. safeMax = Character.MIN_VALUE; safeMin = Character.MAX_VALUE; } this.safeMin = safeMin; this.safeMax = safeMax; }
/** * Creates a new ArrayBasedCharEscaper instance with the given replacement map and specified safe * range. If {@code safeMax < safeMin} then no characters are considered safe. This initializer is * useful when explicit instances of ArrayBasedEscaperMap are used to allow the sharing of large * replacement mappings. * * <p>If a character has no mapped replacement then it is checked against the safe range. If it * lies outside that, then {@link #escapeUnsafe} is called, otherwise no escaping is performed. * * @param escaperMap the mapping of characters to be escaped * @param safeMin the lowest character value in the safe range * @param safeMax the highest character value in the safe range */ protected ArrayBasedCharEscaper(ArrayBasedEscaperMap escaperMap, char safeMin, char safeMax) { checkNotNull(escaperMap); // GWT specific check (do not optimize) this.replacements = escaperMap.getReplacementArray(); this.replacementsLength = replacements.length; 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 (almost certainly) fail. safeMax = Character.MIN_VALUE; safeMin = Character.MAX_VALUE; } this.safeMin = safeMin; this.safeMax = safeMax; }
@Nullable String unsafeReplacement) { this.replacements = escaperMap.getReplacementArray(); this.replacementsLength = replacements.length; if (safeMax < safeMin) {
@NullableDecl String unsafeReplacement) { this.replacements = escaperMap.getReplacementArray(); this.replacementsLength = replacements.length; if (safeMax < safeMin) {
public void testEmptyMap() { Map<Character, String> map = ImmutableMap.of(); ArrayBasedEscaperMap fem = ArrayBasedEscaperMap.create(map); // Non-null array of zero length. assertEquals(0, fem.getReplacementArray().length); }
public void testMapLength() { Map<Character, String> map = ImmutableMap.of( 'a', "first", 'z', "last"); ArrayBasedEscaperMap fem = ArrayBasedEscaperMap.create(map); // Array length is highest character value + 1 assertEquals('z' + 1, fem.getReplacementArray().length); }
@NullableDecl String unsafeReplacement) { this.replacements = escaperMap.getReplacementArray(); this.replacementsLength = replacements.length; if (safeMax < safeMin) {
public void testMapping() { Map<Character, String> map = ImmutableMap.of( '\0', "zero", 'a', "first", 'b', "second", 'z', "last", '\uFFFF', "biggest"); ArrayBasedEscaperMap fem = ArrayBasedEscaperMap.create(map); char[][] replacementArray = fem.getReplacementArray(); // Array length is highest character value + 1 assertEquals(65536, replacementArray.length); // The final element should always be non null. assertNotNull(replacementArray[replacementArray.length - 1]); // Exhaustively check all mappings (an int index avoids wrapping). for (int n = 0; n < replacementArray.length; ++n) { char c = (char) n; if (replacementArray[n] != null) { assertEquals(map.get(c), new String(replacementArray[n])); } else { assertFalse(map.containsKey(c)); } } } }
/** * Creates a new ArrayBasedCharEscaper instance with the given replacement map * and specified safe range. If {@code safeMax < safeMin} then no characters * are considered safe. This initializer is useful when explicit instances of * ArrayBasedEscaperMap are used to allow the sharing of large replacement * mappings. * * <p>If a character has no mapped replacement then it is checked against the * safe range. If it lies outside that, then {@link #escapeUnsafe} is * called, otherwise no escaping is performed. * * @param escaperMap the mapping of characters to be escaped * @param safeMin the lowest character value in the safe range * @param safeMax the highest character value in the safe range */ protected ArrayBasedCharEscaper(ArrayBasedEscaperMap escaperMap, char safeMin, char safeMax) { checkNotNull(escaperMap); // GWT specific check (do not optimize) this.replacements = escaperMap.getReplacementArray(); this.replacementsLength = replacements.length; 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 (almost certainly) fail. safeMax = Character.MIN_VALUE; safeMin = Character.MAX_VALUE; } this.safeMin = safeMin; this.safeMax = safeMax; }
/** * Creates a new ArrayBasedCharEscaper instance with the given replacement map * and specified safe range. If {@code safeMax < safeMin} then no characters * are considered safe. This initializer is useful when explicit instances of * ArrayBasedEscaperMap are used to allow the sharing of large replacement * mappings. * * <p>If a character has no mapped replacement then it is checked against the * safe range. If it lies outside that, then {@link #escapeUnsafe} is * called, otherwise no escaping is performed. * * @param escaperMap the mapping of characters to be escaped * @param safeMin the lowest character value in the safe range * @param safeMax the highest character value in the safe range */ protected ArrayBasedCharEscaper(ArrayBasedEscaperMap escaperMap, char safeMin, char safeMax) { checkNotNull(escaperMap); // GWT specific check (do not optimize) this.replacements = escaperMap.getReplacementArray(); this.replacementsLength = replacements.length; 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 (almost certainly) fail. safeMax = Character.MIN_VALUE; safeMin = Character.MAX_VALUE; } this.safeMin = safeMin; this.safeMax = safeMax; }
/** * Creates a new ArrayBasedCharEscaper instance with the given replacement map * and specified safe range. If {@code safeMax < safeMin} then no characters * are considered safe. This initializer is useful when explicit instances of * ArrayBasedEscaperMap are used to allow the sharing of large replacement * mappings. * * <p>If a character has no mapped replacement then it is checked against the * safe range. If it lies outside that, then {@link #escapeUnsafe} is * called, otherwise no escaping is performed. * * @param escaperMap the mapping of characters to be escaped * @param safeMin the lowest character value in the safe range * @param safeMax the highest character value in the safe range */ protected ArrayBasedCharEscaper(ArrayBasedEscaperMap escaperMap, char safeMin, char safeMax) { checkNotNull(escaperMap); // GWT specific check (do not optimize) this.replacements = escaperMap.getReplacementArray(); this.replacementsLength = replacements.length; 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 (almost certainly) fail. safeMax = Character.MIN_VALUE; safeMin = Character.MAX_VALUE; } this.safeMin = safeMin; this.safeMax = safeMax; }
/** * Creates a new ArrayBasedCharEscaper instance with the given replacement map * and specified safe range. If {@code safeMax < safeMin} then no characters * are considered safe. This initializer is useful when explicit instances of * ArrayBasedEscaperMap are used to allow the sharing of large replacement * mappings. * * <p>If a character has no mapped replacement then it is checked against the * safe range. If it lies outside that, then {@link #escapeUnsafe} is * called, otherwise no escaping is performed. * * @param escaperMap the mapping of characters to be escaped * @param safeMin the lowest character value in the safe range * @param safeMax the highest character value in the safe range */ protected ArrayBasedCharEscaper(ArrayBasedEscaperMap escaperMap, char safeMin, char safeMax) { checkNotNull(escaperMap); // GWT specific check (do not optimize) this.replacements = escaperMap.getReplacementArray(); this.replacementsLength = replacements.length; 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 (almost certainly) fail. safeMax = Character.MIN_VALUE; safeMin = Character.MAX_VALUE; } this.safeMin = safeMin; this.safeMax = safeMax; }
/** * Creates a new ArrayBasedCharEscaper instance with the given replacement map * and specified safe range. If {@code safeMax < safeMin} then no characters * are considered safe. This initializer is useful when explicit instances of * ArrayBasedEscaperMap are used to allow the sharing of large replacement * mappings. * * <p>If a character has no mapped replacement then it is checked against the * safe range. If it lies outside that, then {@link #escapeUnsafe} is * called, otherwise no escaping is performed. * * @param escaperMap the mapping of characters to be escaped * @param safeMin the lowest character value in the safe range * @param safeMax the highest character value in the safe range */ protected ArrayBasedCharEscaper(ArrayBasedEscaperMap escaperMap, char safeMin, char safeMax) { checkNotNull(escaperMap); // GWT specific check (do not optimize) this.replacements = escaperMap.getReplacementArray(); this.replacementsLength = replacements.length; 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 (almost certainly) fail. safeMax = Character.MIN_VALUE; safeMin = Character.MAX_VALUE; } this.safeMin = safeMin; this.safeMax = safeMax; }
/** * Creates a new ArrayBasedCharEscaper instance with the given replacement map and specified safe * range. If {@code safeMax < safeMin} then no characters are considered safe. This initializer is * useful when explicit instances of ArrayBasedEscaperMap are used to allow the sharing of large * replacement mappings. * * <p>If a character has no mapped replacement then it is checked against the safe range. If it * lies outside that, then {@link #escapeUnsafe} is called, otherwise no escaping is performed. * * @param escaperMap the mapping of characters to be escaped * @param safeMin the lowest character value in the safe range * @param safeMax the highest character value in the safe range */ protected ArrayBasedCharEscaper(ArrayBasedEscaperMap escaperMap, char safeMin, char safeMax) { checkNotNull(escaperMap); // GWT specific check (do not optimize) this.replacements = escaperMap.getReplacementArray(); this.replacementsLength = replacements.length; 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 (almost certainly) fail. safeMax = Character.MIN_VALUE; safeMin = Character.MAX_VALUE; } this.safeMin = safeMin; this.safeMax = safeMax; }
/** * Creates a new ArrayBasedCharEscaper instance with the given replacement map and specified safe * range. If {@code safeMax < safeMin} then no characters are considered safe. This initializer is * useful when explicit instances of ArrayBasedEscaperMap are used to allow the sharing of large * replacement mappings. * * <p>If a character has no mapped replacement then it is checked against the safe range. If it * lies outside that, then {@link #escapeUnsafe} is called, otherwise no escaping is performed. * * @param escaperMap the mapping of characters to be escaped * @param safeMin the lowest character value in the safe range * @param safeMax the highest character value in the safe range */ protected ArrayBasedCharEscaper(ArrayBasedEscaperMap escaperMap, char safeMin, char safeMax) { checkNotNull(escaperMap); // GWT specific check (do not optimize) this.replacements = escaperMap.getReplacementArray(); this.replacementsLength = replacements.length; 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 (almost certainly) fail. safeMax = Character.MIN_VALUE; safeMin = Character.MAX_VALUE; } this.safeMin = safeMin; this.safeMax = safeMax; }
/** * Creates a new ArrayBasedCharEscaper instance with the given replacement map * and specified safe range. If {@code safeMax < safeMin} then no characters * are considered safe. This initializer is useful when explicit instances of * ArrayBasedEscaperMap are used to allow the sharing of large replacement * mappings. * * <p>If a character has no mapped replacement then it is checked against the * safe range. If it lies outside that, then {@link #escapeUnsafe} is * called, otherwise no escaping is performed. * * @param escaperMap the mapping of characters to be escaped * @param safeMin the lowest character value in the safe range * @param safeMax the highest character value in the safe range */ protected ArrayBasedCharEscaper(ArrayBasedEscaperMap escaperMap, char safeMin, char safeMax) { checkNotNull(escaperMap); // GWT specific check (do not optimize) this.replacements = escaperMap.getReplacementArray(); this.replacementsLength = replacements.length; 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 (almost certainly) fail. safeMax = Character.MIN_VALUE; safeMin = Character.MAX_VALUE; } this.safeMin = safeMin; this.safeMax = safeMax; }
public void testEmptyMap() { Map<Character, String> map = ImmutableMap.of(); ArrayBasedEscaperMap fem = ArrayBasedEscaperMap.create(map); // Non-null array of zero length. assertEquals(0, fem.getReplacementArray().length); }
public void testMapLength() { Map<Character, String> map = ImmutableMap.of( 'a', "first", 'z', "last"); ArrayBasedEscaperMap fem = ArrayBasedEscaperMap.create(map); // Array length is highest character value + 1 assertEquals('z' + 1, fem.getReplacementArray().length); }
public void testMapping() { Map<Character, String> map = ImmutableMap.of( '\0', "zero", 'a', "first", 'b', "second", 'z', "last", '\uFFFF', "biggest"); ArrayBasedEscaperMap fem = ArrayBasedEscaperMap.create(map); char[][] replacementArray = fem.getReplacementArray(); // Array length is highest character value + 1 assertEquals(65536, replacementArray.length); // The final element should always be non null. assertNotNull(replacementArray[replacementArray.length - 1]); // Exhaustively check all mappings (an int index avoids wrapping). for (int n = 0; n < replacementArray.length; ++n) { char c = (char) n; if (replacementArray[n] != null) { assertEquals(map.get(c), new String(replacementArray[n])); } else { assertFalse(map.containsKey(c)); } } } }