/*

 * Copyright (c) 2005, 2015, Oracle and/or its affiliates. All rights reserved.

 */

/*

 * Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements.  See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You 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.sun.org.apache.xerces.internal.jaxp;

import com.sun.org.apache.xerces.internal.impl.Constants;

import com.sun.org.apache.xerces.internal.util.SAXMessageFormatter;

import java.util.HashMap;

import java.util.Map;

import javax.xml.XMLConstants;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.parsers.SAXParser;

import javax.xml.parsers.SAXParserFactory;

import javax.xml.validation.Schema;

import org.xml.sax.SAXException;

import org.xml.sax.SAXNotRecognizedException;

import org.xml.sax.SAXNotSupportedException;

/**

 * This is the implementation specific class for the

 * <code>javax.xml.parsers.SAXParserFactory</code>. This is the platform

 * default implementation for the platform.

 *

 * @author Rajiv Mordani

 * @author Edwin Goei

 *

 */

public class SAXParserFactoryImpl extends SAXParserFactory {

    /** Feature identifier: validation. */

    private static final String VALIDATION_FEATURE =

        Constants.SAX_FEATURE_PREFIX + Constants.VALIDATION_FEATURE;

    /** Feature identifier: namespaces. */

    private static final String NAMESPACES_FEATURE =

        Constants.SAX_FEATURE_PREFIX + Constants.NAMESPACES_FEATURE;

    /** Feature identifier: XInclude processing */

    private static final String XINCLUDE_FEATURE =

        Constants.XERCES_FEATURE_PREFIX + Constants.XINCLUDE_FEATURE;

    private Map<String, Boolean> features;

    private Schema grammar;

    private boolean isXIncludeAware;

    /**

     * State of the secure processing feature, initially <code>false</code>

     */

    private boolean fSecureProcess = true;

    /**

     * Creates a new instance of <code>SAXParser</code> using the currently

     * configured factory parameters.

     * @return javax.xml.parsers.SAXParser

     */

    public SAXParser newSAXParser()

        throws ParserConfigurationException

    {

        SAXParser saxParserImpl;

        try {

            saxParserImpl = new SAXParserImpl(this, features, fSecureProcess);

        } catch (SAXException se) {

            // Translate to ParserConfigurationException

            throw new ParserConfigurationException(se.getMessage());

        }

        return saxParserImpl;

    }

    /**

     * Common code for translating exceptions

     */

    private SAXParserImpl newSAXParserImpl()

        throws ParserConfigurationException, SAXNotRecognizedException,

        SAXNotSupportedException

    {

        SAXParserImpl saxParserImpl;

        try {

            saxParserImpl = new SAXParserImpl(this, features);

        } catch (SAXNotSupportedException e) {

            throw e;

        } catch (SAXNotRecognizedException e) {

            throw e;

        } catch (SAXException se) {

            throw new ParserConfigurationException(se.getMessage());

        }

        return saxParserImpl;

    }

    /**

     * Sets the particular feature in the underlying implementation of

     * org.xml.sax.XMLReader.

     */

    public void setFeature(String name, boolean value)

        throws ParserConfigurationException, SAXNotRecognizedException,

                SAXNotSupportedException {

        if (name == null) {

            throw new NullPointerException();

        }

        // If this is the secure processing feature, save it then return.

        if (name.equals(XMLConstants.FEATURE_SECURE_PROCESSING)) {

            if (System.getSecurityManager() != null && (!value)) {

                throw new ParserConfigurationException(

                        SAXMessageFormatter.formatMessage(null,

                        "jaxp-secureprocessing-feature", null));

            }

            fSecureProcess = value;

            putInFeatures(name, value);

            return;

        }

        // XXX This is ugly.  We have to collect the features and then

        // later create an XMLReader to verify the features.

        putInFeatures(name, value);

        // Test the feature by possibly throwing SAX exceptions

        try {

            newSAXParserImpl();

        } catch (SAXNotSupportedException e) {

            features.remove(name);

            throw e;

        } catch (SAXNotRecognizedException e) {

            features.remove(name);

            throw e;

        }

    }

    /**

     * returns the particular property requested for in the underlying

     * implementation of org.xml.sax.XMLReader.

     */

    public boolean getFeature(String name)

        throws ParserConfigurationException, SAXNotRecognizedException,

                SAXNotSupportedException {

        if (name == null) {

            throw new NullPointerException();

        }

        if (name.equals(XMLConstants.FEATURE_SECURE_PROCESSING)) {

            return fSecureProcess;

        }

        // Check for valid name by creating a dummy XMLReader to get

        // feature value

        return newSAXParserImpl().getXMLReader().getFeature(name);

    }

    public Schema getSchema() {

        return grammar;

    }

    public void setSchema(Schema grammar) {

        this.grammar = grammar;

    }

    public boolean isXIncludeAware() {

        return getFromFeatures(XINCLUDE_FEATURE);

    }

    public void setXIncludeAware(boolean state) {

        putInFeatures(XINCLUDE_FEATURE, state);

    }

    public void setValidating(boolean validating) {

        putInFeatures(VALIDATION_FEATURE, validating);

    }

    public boolean isValidating() {

         return getFromFeatures(VALIDATION_FEATURE);

    }

    private void putInFeatures(String name, boolean value){

         if (features == null) {

            features = new HashMap<>();

        }

        features.put(name, value ? Boolean.TRUE : Boolean.FALSE);

    }

    private boolean getFromFeatures(String name){

         if (features == null){

            return false;

         }

         else {

             Boolean value = features.get(name);

             return (value == null) ? false : value;

         }

    }

    public boolean isNamespaceAware() {

        return getFromFeatures(NAMESPACES_FEATURE);

    }

    public void setNamespaceAware(boolean awareness) {

       putInFeatures(NAMESPACES_FEATURE, awareness);

    }

 }