001/*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 * 
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 * 
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017package org.apache.commons.lang3.text.translate;
018
019import java.io.IOException;
020import java.io.Writer;
021import java.util.Arrays;
022import java.util.EnumSet;
023
024/**
025 * Translate XML numeric entities of the form &#[xX]?\d+;? to 
026 * the specific codepoint.
027 *
028 * Note that the semi-colon is optional.
029 * 
030 * @since 3.0
031 */
032public class NumericEntityUnescaper extends CharSequenceTranslator {
033
034    public static enum OPTION { semiColonRequired, semiColonOptional, errorIfNoSemiColon }
035
036    // TODO?: Create an OptionsSet class to hide some of the conditional logic below
037    private final EnumSet<OPTION> options;
038
039    /**
040     * Create a UnicodeUnescaper.
041     *
042     * The constructor takes a list of options, only one type of which is currently 
043     * available (whether to allow, error or ignore the semi-colon on the end of a 
044     * numeric entity to being missing).
045     *
046     * For example, to support numeric entities without a ';':
047     *    new NumericEntityUnescaper(NumericEntityUnescaper.OPTION.semiColonOptional)
048     * and to throw an IllegalArgumentException when they're missing:
049     *    new NumericEntityUnescaper(NumericEntityUnescaper.OPTION.errorIfNoSemiColon)
050     *
051     * Note that the default behaviour is to ignore them. 
052     *
053     * @param options to apply to this unescaper
054     */
055    public NumericEntityUnescaper(final OPTION... options) {
056        if(options.length > 0) {
057            this.options = EnumSet.copyOf(Arrays.asList(options));
058        } else {
059            this.options = EnumSet.copyOf(Arrays.asList(new OPTION[] { OPTION.semiColonRequired }));
060        }
061    }
062
063    /**
064     * Whether the passed in option is currently set.
065     *
066     * @param option to check state of
067     * @return whether the option is set
068     */
069    public boolean isSet(final OPTION option) { 
070        return options == null ? false : options.contains(option);
071    }
072
073    /**
074     * {@inheritDoc}
075     */
076    @Override
077    public int translate(final CharSequence input, final int index, final Writer out) throws IOException {
078        final int seqEnd = input.length();
079        // Uses -2 to ensure there is something after the &#
080        if(input.charAt(index) == '&' && index < seqEnd - 2 && input.charAt(index + 1) == '#') {
081            int start = index + 2;
082            boolean isHex = false;
083
084            final char firstChar = input.charAt(start);
085            if(firstChar == 'x' || firstChar == 'X') {
086                start++;
087                isHex = true;
088
089                // Check there's more than just an x after the &#
090                if(start == seqEnd) {
091                    return 0;
092                }
093            }
094
095            int end = start;
096            // Note that this supports character codes without a ; on the end
097            while(end < seqEnd && ( input.charAt(end) >= '0' && input.charAt(end) <= '9' ||
098                                    input.charAt(end) >= 'a' && input.charAt(end) <= 'f' ||
099                                    input.charAt(end) >= 'A' && input.charAt(end) <= 'F' ) )
100            {
101                end++;
102            }
103
104            final boolean semiNext = end != seqEnd && input.charAt(end) == ';';
105
106            if(!semiNext) {
107                if(isSet(OPTION.semiColonRequired)) {
108                    return 0;
109                } else
110                if(isSet(OPTION.errorIfNoSemiColon)) {
111                    throw new IllegalArgumentException("Semi-colon required at end of numeric entity");
112                }
113            }
114
115            int entityValue;
116            try {
117                if(isHex) {
118                    entityValue = Integer.parseInt(input.subSequence(start, end).toString(), 16);
119                } else {
120                    entityValue = Integer.parseInt(input.subSequence(start, end).toString(), 10);
121                }
122            } catch(final NumberFormatException nfe) {
123                return 0;
124            }
125
126            if(entityValue > 0xFFFF) {
127                final char[] chrs = Character.toChars(entityValue);
128                out.write(chrs[0]);
129                out.write(chrs[1]);
130            } else {
131                out.write(entityValue);
132            }
133
134            return 2 + end - start + (isHex ? 1 : 0) + (semiNext ? 1 : 0);
135        }
136        return 0;
137    }
138}