/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 * THIS FILE WAS MODIFIED BY SUN MICROSYSTEMS, INC.

 */

package com.sun.xml.internal.fastinfoset;

import com.sun.xml.internal.fastinfoset.algorithm.BuiltInEncodingAlgorithmFactory;

import com.sun.xml.internal.fastinfoset.org.apache.xerces.util.XMLChar;

import com.sun.xml.internal.fastinfoset.util.CharArrayIntMap;

import com.sun.xml.internal.fastinfoset.util.KeyIntMap;

import com.sun.xml.internal.fastinfoset.util.LocalNameQualifiedNamesMap;

import com.sun.xml.internal.fastinfoset.util.StringIntMap;

import com.sun.xml.internal.fastinfoset.vocab.SerializerVocabulary;

import java.io.IOException;

import java.io.OutputStream;

import java.util.HashMap;

import java.util.Map;

import com.sun.xml.internal.org.jvnet.fastinfoset.EncodingAlgorithm;

import com.sun.xml.internal.org.jvnet.fastinfoset.EncodingAlgorithmException;

import com.sun.xml.internal.org.jvnet.fastinfoset.EncodingAlgorithmIndexes;

import com.sun.xml.internal.org.jvnet.fastinfoset.ExternalVocabulary;

import com.sun.xml.internal.org.jvnet.fastinfoset.FastInfosetException;

import com.sun.xml.internal.org.jvnet.fastinfoset.FastInfosetSerializer;

import com.sun.xml.internal.org.jvnet.fastinfoset.RestrictedAlphabet;

import com.sun.xml.internal.org.jvnet.fastinfoset.VocabularyApplicationData;

import org.xml.sax.helpers.DefaultHandler;

/**

 * Abstract encoder for developing concrete encoders.

 *

 * Concrete implementations extending Encoder will utilize methods on Encoder

 * to encode XML infoset according to the Fast Infoset standard. It is the

 * responsibility of the concrete implementation to ensure that methods are

 * invoked in the correct order to produce a valid fast infoset document.

 *

 * <p>

 * This class extends org.sax.xml.DefaultHandler so that concrete SAX

 * implementations can be used with javax.xml.parsers.SAXParser and the parse

 * methods that take org.sax.xml.DefaultHandler as a parameter.

 *

 * <p>

 * Buffering of octets that are written to an {@link java.io.OutputStream} is

 * supported in a similar manner to a {@link java.io.BufferedOutputStream}.

 * Combining buffering with encoding enables better performance.

 *

 * <p>

 * More than one fast infoset document may be encoded to the

 * {@link java.io.OutputStream}.

 *

 */

public abstract class Encoder extends DefaultHandler implements FastInfosetSerializer {

    /**

     * Character encoding scheme system property for the encoding

     * of content and attribute values.

     */

    public static final String CHARACTER_ENCODING_SCHEME_SYSTEM_PROPERTY =

        "com.sun.xml.internal.fastinfoset.serializer.character-encoding-scheme";

    /**

     * Default character encoding scheme system property for the encoding

     * of content and attribute values.

     */

    protected static final String _characterEncodingSchemeSystemDefault = getDefaultEncodingScheme();

    private static String getDefaultEncodingScheme() {

        String p = System.getProperty(CHARACTER_ENCODING_SCHEME_SYSTEM_PROPERTY,

            UTF_8);

        if (p.equals(UTF_16BE)) {

            return UTF_16BE;

        } else {

            return UTF_8;

        }

    }

    private static int[] NUMERIC_CHARACTERS_TABLE;

    private static int[] DATE_TIME_CHARACTERS_TABLE;

    static {

        NUMERIC_CHARACTERS_TABLE = new int[maxCharacter(RestrictedAlphabet.NUMERIC_CHARACTERS) + 1];

        DATE_TIME_CHARACTERS_TABLE = new int[maxCharacter(RestrictedAlphabet.DATE_TIME_CHARACTERS) + 1];

        for (int i = 0; i < NUMERIC_CHARACTERS_TABLE.length ; i++) {

            NUMERIC_CHARACTERS_TABLE[i] = -1;

        }

        for (int i = 0; i < DATE_TIME_CHARACTERS_TABLE.length ; i++) {

            DATE_TIME_CHARACTERS_TABLE[i] = -1;

        }

        for (int i = 0; i < RestrictedAlphabet.NUMERIC_CHARACTERS.length() ; i++) {

            NUMERIC_CHARACTERS_TABLE[RestrictedAlphabet.NUMERIC_CHARACTERS.charAt(i)] = i;

        }

        for (int i = 0; i < RestrictedAlphabet.DATE_TIME_CHARACTERS.length() ; i++) {

            DATE_TIME_CHARACTERS_TABLE[RestrictedAlphabet.DATE_TIME_CHARACTERS.charAt(i)] = i;

        }

    }

    private static int maxCharacter(String alphabet) {

        int c = 0;

        for (int i = 0; i < alphabet.length() ; i++) {

            if (c < alphabet.charAt(i)) {

                c = alphabet.charAt(i);

            }

        }

        return c;

    }

    /**

     * True if DTD and internal subset shall be ignored.

     */

    private boolean _ignoreDTD;

    /**

     * True if comments shall be ignored.

     */

    private boolean _ignoreComments;

    /**

     * True if procesing instructions shall be ignored.

     */

    private boolean _ignoreProcessingInstructions;

    /**

     * True if white space characters for text content shall be ignored.

     */

    private boolean _ignoreWhiteSpaceTextContent;

    /**

     * True, if the local name string is used as the key to find the

     * associated set of qualified names.

     * <p>

     * False,  if the <prefix>:<local name> string is used as the key

     * to find the associated set of qualified names.

     */

    private boolean _useLocalNameAsKeyForQualifiedNameLookup;

    /**

     * True if strings for text content and attribute values will be

     * UTF-8 encoded otherwise they will be UTF-16 encoded.

     */

    private boolean _encodingStringsAsUtf8 = true;

    /**

     * Encoding constant generated from the string encoding.

     */

    private int _nonIdentifyingStringOnThirdBitCES;

    /**

     * Encoding constant generated from the string encoding.

     */

    private int _nonIdentifyingStringOnFirstBitCES;

    /**

     * The map of URIs to algorithms.

     */

    private Map _registeredEncodingAlgorithms = new HashMap();

    /**

     * The vocabulary that is used by the encoder

     */

    protected SerializerVocabulary _v;

    /**

     * The vocabulary application data that is used by the encoder

     */

    protected VocabularyApplicationData _vData;

    /**

     * True if the vocubulary is internal to the encoder

     */

    private boolean _vIsInternal;

    /**

     * True if terminatation of an information item is required

     */

    protected boolean _terminate = false;

    /**

     * The current octet that is to be written.

     */

    protected int _b;

    /**

     * The {@link java.io.OutputStream} that the encoded XML infoset (the

     * fast infoset document) is written to.

     */

    protected OutputStream _s;

    /**

     * The internal buffer of characters used for the UTF-8 or UTF-16 encoding

     * of characters.

     */

    protected char[] _charBuffer = new char[512];

    /**

     * The internal buffer of bytes.

     */

    protected byte[] _octetBuffer = new byte[1024];

    /**

     * The current position in the internal buffer.

     */

    protected int _octetBufferIndex;

    /**

     * The current mark in the internal buffer.

     *

     * <p>

     * If the value of the mark is < 0 then the mark is not set.

     */

    protected int _markIndex = -1;

    /**

     * The minimum size of [normalized value] of Attribute Information

     * Items that will be indexed.

     */

    protected int minAttributeValueSize = FastInfosetSerializer.MIN_ATTRIBUTE_VALUE_SIZE;

    /**

     * The maximum size of [normalized value] of Attribute Information

     * Items that will be indexed.

     */

    protected int maxAttributeValueSize = FastInfosetSerializer.MAX_ATTRIBUTE_VALUE_SIZE;

    /**

     * The limit on the size of indexed Map for attribute values

     * Limit is measured in characters number

     */

    protected int attributeValueMapTotalCharactersConstraint = FastInfosetSerializer.ATTRIBUTE_VALUE_MAP_MEMORY_CONSTRAINT / 2;

    /**

     * The minimum size of character content chunks

     * of Character Information Items or Comment Information Items that

     * will be indexed.

     */

    protected int minCharacterContentChunkSize = FastInfosetSerializer.MIN_CHARACTER_CONTENT_CHUNK_SIZE;

    /**

     * The maximum size of character content chunks

     * of Character Information Items or Comment Information Items that

     * will be indexed.

     */

    protected int maxCharacterContentChunkSize = FastInfosetSerializer.MAX_CHARACTER_CONTENT_CHUNK_SIZE;

    /**

     * The limit on the size of indexed Map for character content chunks

     * Limit is measured in characters number

     */

    protected int characterContentChunkMapTotalCharactersConstraint = FastInfosetSerializer.CHARACTER_CONTENT_CHUNK_MAP_MEMORY_CONSTRAINT / 2;

    /**

     * Default constructor for the Encoder.

     */

    protected Encoder() {

        setCharacterEncodingScheme(_characterEncodingSchemeSystemDefault);

    }

    protected Encoder(boolean useLocalNameAsKeyForQualifiedNameLookup) {

        setCharacterEncodingScheme(_characterEncodingSchemeSystemDefault);

        _useLocalNameAsKeyForQualifiedNameLookup = useLocalNameAsKeyForQualifiedNameLookup;

    }

    // FastInfosetSerializer interface

    /**

     * {@inheritDoc}

     */

    public final void setIgnoreDTD(boolean ignoreDTD) {

        _ignoreDTD = ignoreDTD;

    }

    /**

     * {@inheritDoc}

     */

    public final boolean getIgnoreDTD() {

        return _ignoreDTD;

    }

    /**

     * {@inheritDoc}

     */

    public final void setIgnoreComments(boolean ignoreComments) {

        _ignoreComments = ignoreComments;

    }

    /**

     * {@inheritDoc}

     */

    public final boolean getIgnoreComments() {

        return _ignoreComments;

    }

    /**

     * {@inheritDoc}

     */

    public final void setIgnoreProcesingInstructions(boolean

            ignoreProcesingInstructions) {

        _ignoreProcessingInstructions = ignoreProcesingInstructions;

    }

    /**

     * {@inheritDoc}

     */

    public final boolean getIgnoreProcesingInstructions() {

        return _ignoreProcessingInstructions;

    }

    /**

     * {@inheritDoc}

     */

    public final void setIgnoreWhiteSpaceTextContent(boolean ignoreWhiteSpaceTextContent) {

        _ignoreWhiteSpaceTextContent = ignoreWhiteSpaceTextContent;

    }

    /**

     * {@inheritDoc}

     */

    public final boolean getIgnoreWhiteSpaceTextContent() {

        return _ignoreWhiteSpaceTextContent;

    }

    /**

     * {@inheritDoc}

     */

    public void setCharacterEncodingScheme(String characterEncodingScheme) {

        if (characterEncodingScheme.equals(UTF_16BE)) {

            _encodingStringsAsUtf8 = false;

            _nonIdentifyingStringOnThirdBitCES = EncodingConstants.CHARACTER_CHUNK | EncodingConstants.CHARACTER_CHUNK_UTF_16_FLAG;

            _nonIdentifyingStringOnFirstBitCES = EncodingConstants.NISTRING_UTF_16_FLAG;

        } else {

            _encodingStringsAsUtf8 = true;

            _nonIdentifyingStringOnThirdBitCES = EncodingConstants.CHARACTER_CHUNK;

            _nonIdentifyingStringOnFirstBitCES = 0;

        }

    }

    /**

     * {@inheritDoc}

     */

    public String getCharacterEncodingScheme() {

        return (_encodingStringsAsUtf8) ? UTF_8 : UTF_16BE;

    }

    /**

     * {@inheritDoc}

     */

    public void setRegisteredEncodingAlgorithms(Map algorithms) {

        _registeredEncodingAlgorithms = algorithms;

        if (_registeredEncodingAlgorithms == null) {

            _registeredEncodingAlgorithms = new HashMap();

        }

    }

    /**

     * {@inheritDoc}

     */

    public Map getRegisteredEncodingAlgorithms() {

        return _registeredEncodingAlgorithms;

    }

    /**

     * {@inheritDoc}

     */

    public int getMinCharacterContentChunkSize() {

        return minCharacterContentChunkSize;

    }

    /**

     * {@inheritDoc}

     */

    public void setMinCharacterContentChunkSize(int size) {

        if (size < 0 ) {

            size = 0;

        }

        minCharacterContentChunkSize = size;

    }

    /**

     * {@inheritDoc}

     */

    public int getMaxCharacterContentChunkSize() {

        return maxCharacterContentChunkSize;

    }

    /**

     * {@inheritDoc}

     */

    public void setMaxCharacterContentChunkSize(int size) {

        if (size < 0 ) {

            size = 0;

        }

        maxCharacterContentChunkSize = size;

    }

    /**

     * {@inheritDoc}

     */

    public int getCharacterContentChunkMapMemoryLimit() {

        return characterContentChunkMapTotalCharactersConstraint * 2;

    }

    /**

     * {@inheritDoc}

     */

    public void setCharacterContentChunkMapMemoryLimit(int size) {

        if (size < 0 ) {

            size = 0;

        }

        characterContentChunkMapTotalCharactersConstraint = size / 2;

    }

    /**

     * Checks whether character content chunk (its length) matches length limit

     *

     * @param length the length of character content chunk is checking to be added to Map.

     * @return whether character content chunk length matches limit

     */

    public boolean isCharacterContentChunkLengthMatchesLimit(int length) {

        return length >= minCharacterContentChunkSize &&

                length < maxCharacterContentChunkSize;

    }

    /**

     * Checks whether character content table has enough memory to

     * store character content chunk with the given length

     *

     * @param length the length of character content chunk is checking to be added to Map.

     * @param map the custom CharArrayIntMap, which memory limits will be checked.

     * @return whether character content map has enough memory

     */

    public boolean canAddCharacterContentToTable(int length, CharArrayIntMap map) {

        return map.getTotalCharacterCount() + length <

                        characterContentChunkMapTotalCharactersConstraint;

    }

    /**

     * {@inheritDoc}

     */

    public int getMinAttributeValueSize() {

        return minAttributeValueSize;

    }

    /**

     * {@inheritDoc}

     */

    public void setMinAttributeValueSize(int size) {

        if (size < 0 ) {

            size = 0;

        }

        minAttributeValueSize = size;

    }

    /**

     * {@inheritDoc}

     */

    public int getMaxAttributeValueSize() {

        return maxAttributeValueSize;

    }

    /**

     * {@inheritDoc}

     */

    public void setMaxAttributeValueSize(int size) {

        if (size < 0 ) {

            size = 0;

        }

        maxAttributeValueSize = size;

    }

    /**

     * {@inheritDoc}

     */

    public void setAttributeValueMapMemoryLimit(int size) {

        if (size < 0 ) {

            size = 0;

        }

        attributeValueMapTotalCharactersConstraint = size / 2;

    }

    /**

     * {@inheritDoc}

     */

    public int getAttributeValueMapMemoryLimit() {

        return attributeValueMapTotalCharactersConstraint * 2;

    }

    /**

     * Checks whether attribute value (its length) matches length limit

     *

     * @param length the length of attribute

     * @return whether attribute value matches limit

     */

    public boolean isAttributeValueLengthMatchesLimit(int length) {

        return length >= minAttributeValueSize &&

                length < maxAttributeValueSize;

    }