jdk8-mips64-public/jaxws: comparison src/share/jaxws_classes/com/sun/xml/internal/bind/v2/ContextFactory.java

--1:000000000000
+:373ffda63c9a
+/*
+* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
+* 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.
+*/
+package com.sun.xml.internal.bind.v2;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.StringTokenizer;
+import java.util.logging.Level;
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+import com.sun.istack.internal.FinalArrayList;
+import com.sun.xml.internal.bind.Util;
+import com.sun.xml.internal.bind.api.JAXBRIContext;
+import com.sun.xml.internal.bind.api.TypeReference;
+import com.sun.xml.internal.bind.v2.model.annotation.RuntimeAnnotationReader;
+import com.sun.xml.internal.bind.v2.runtime.JAXBContextImpl;
+import com.sun.xml.internal.bind.v2.util.TypeCast;
+/**
+* This class is responsible for producing RI JAXBContext objects.  In
+* the RI, this is the class that the javax.xml.bind.context.factory
+* property will point to.
+*
+* <p>
+* Used to create JAXBContext objects for v1.0.1 and forward
+*
+* @since 2.0
+* @author Kohsuke Kawaguchi
+*/
+public class ContextFactory {
+/**
+* The API will invoke this method via reflection
+*/
+public static JAXBContext createContext(Class[] classes, Map<String,Object> properties ) throws JAXBException {
+// fool-proof check, and copy the map to make it easier to find unrecognized properties.
+if(properties==null)
+properties = Collections.emptyMap();
+else
+properties = new HashMap<String,Object>(properties);
+String defaultNsUri = getPropertyValue(properties,JAXBRIContext.DEFAULT_NAMESPACE_REMAP,String.class);
+Boolean c14nSupport = getPropertyValue(properties,JAXBRIContext.CANONICALIZATION_SUPPORT,Boolean.class);
+if(c14nSupport==null)
+c14nSupport = false;
+Boolean disablesecurityProcessing = getPropertyValue(properties, JAXBRIContext.DISABLE_XML_SECURITY, Boolean.class);
+if (disablesecurityProcessing==null)
+disablesecurityProcessing = false;
+Boolean allNillable = getPropertyValue(properties,JAXBRIContext.TREAT_EVERYTHING_NILLABLE,Boolean.class);
+if(allNillable==null)
+allNillable = false;
+Boolean retainPropertyInfo = getPropertyValue(properties, JAXBRIContext.RETAIN_REFERENCE_TO_INFO, Boolean.class);
+if(retainPropertyInfo==null)
+retainPropertyInfo = false;
+Boolean supressAccessorWarnings = getPropertyValue(properties, JAXBRIContext.SUPRESS_ACCESSOR_WARNINGS, Boolean.class);
+if(supressAccessorWarnings==null)
+supressAccessorWarnings = false;
+Boolean improvedXsiTypeHandling = getPropertyValue(properties, JAXBRIContext.IMPROVED_XSI_TYPE_HANDLING, Boolean.class);
+if (improvedXsiTypeHandling == null) {
+String improvedXsiSystemProperty = Util.getSystemProperty(JAXBRIContext.IMPROVED_XSI_TYPE_HANDLING);
+if (improvedXsiSystemProperty == null) {
+improvedXsiTypeHandling = true;
+} else {
+improvedXsiTypeHandling = Boolean.valueOf(improvedXsiSystemProperty);
+}
+}
+Boolean xmlAccessorFactorySupport = getPropertyValue(properties,
+JAXBRIContext.XMLACCESSORFACTORY_SUPPORT,Boolean.class);
+if(xmlAccessorFactorySupport==null){
+xmlAccessorFactorySupport = false;
+Util.getClassLogger().log(Level.FINE, "Property " +
+JAXBRIContext.XMLACCESSORFACTORY_SUPPORT +
+"is not active.  Using JAXB's implementation");
+}
+RuntimeAnnotationReader ar = getPropertyValue(properties,JAXBRIContext.ANNOTATION_READER,RuntimeAnnotationReader.class);
+Collection<TypeReference> tr = getPropertyValue(properties, JAXBRIContext.TYPE_REFERENCES, Collection.class);
+if (tr == null) {
+tr = Collections.<TypeReference>emptyList();
+}
+Map<Class,Class> subclassReplacements;
+try {
+subclassReplacements = TypeCast.checkedCast(
+getPropertyValue(properties, JAXBRIContext.SUBCLASS_REPLACEMENTS, Map.class), Class.class, Class.class);
+} catch (ClassCastException e) {
+throw new JAXBException(Messages.INVALID_TYPE_IN_MAP.format(),e);
+}
+if(!properties.isEmpty()) {
+throw new JAXBException(Messages.UNSUPPORTED_PROPERTY.format(properties.keySet().iterator().next()));
+}
+JAXBContextImpl.JAXBContextBuilder builder = new JAXBContextImpl.JAXBContextBuilder();
+builder.setClasses(classes);
+builder.setTypeRefs(tr);
+builder.setSubclassReplacements(subclassReplacements);
+builder.setDefaultNsUri(defaultNsUri);
+builder.setC14NSupport(c14nSupport);
+builder.setAnnotationReader(ar);
+builder.setXmlAccessorFactorySupport(xmlAccessorFactorySupport);
+builder.setAllNillable(allNillable);
+builder.setRetainPropertyInfo(retainPropertyInfo);
+builder.setSupressAccessorWarnings(supressAccessorWarnings);
+builder.setImprovedXsiTypeHandling(improvedXsiTypeHandling);
+builder.setDisableSecurityProcessing(disablesecurityProcessing);
+return builder.build();
+}
+/**
+* If a key is present in the map, remove the value and return it.
+*/
+private static <T> T getPropertyValue(Map<String, Object> properties, String keyName, Class<T> type ) throws JAXBException {
+Object o = properties.get(keyName);
+if(o==null)     return null;
+properties.remove(keyName);
+if(!type.isInstance(o))
+throw new JAXBException(Messages.INVALID_PROPERTY_VALUE.format(keyName,o));
+else
+return type.cast(o);
+}
+/**
+*
+* @param classes
+* @param typeRefs
+* @param subclassReplacements
+* @param defaultNsUri
+* @param c14nSupport
+* @param ar
+* @param xmlAccessorFactorySupport
+* @param allNillable
+* @param retainPropertyInfo
+* @return
+* @throws JAXBException
+* @deprecated use createContext(Class[] classes, Map<String,Object> properties) method instead
+*/
+@Deprecated
+public static JAXBRIContext createContext( Class[] classes,
+Collection<TypeReference> typeRefs, Map<Class,Class> subclassReplacements,
+String defaultNsUri, boolean c14nSupport, RuntimeAnnotationReader ar,
+boolean xmlAccessorFactorySupport, boolean allNillable, boolean retainPropertyInfo) throws JAXBException {
+return createContext(classes, typeRefs, subclassReplacements,
+defaultNsUri, c14nSupport, ar, xmlAccessorFactorySupport,
+allNillable, retainPropertyInfo, false);
+}
+/**
+*
+* @param classes
+* @param typeRefs
+* @param subclassReplacements
+* @param defaultNsUri
+* @param c14nSupport
+* @param ar
+* @param xmlAccessorFactorySupport
+* @param allNillable
+* @param retainPropertyInfo
+* @param improvedXsiTypeHandling
+* @return
+* @throws JAXBException
+* @deprecated use createContext( Class[] classes, Map<String,Object> properties) method instead
+*/
+@Deprecated
+public static JAXBRIContext createContext( Class[] classes,
+Collection<TypeReference> typeRefs, Map<Class,Class> subclassReplacements,
+String defaultNsUri, boolean c14nSupport, RuntimeAnnotationReader ar,
+boolean xmlAccessorFactorySupport, boolean allNillable, boolean retainPropertyInfo, boolean improvedXsiTypeHandling) throws JAXBException {
+JAXBContextImpl.JAXBContextBuilder builder = new JAXBContextImpl.JAXBContextBuilder();
+builder.setClasses(classes);
+builder.setTypeRefs(typeRefs);
+builder.setSubclassReplacements(subclassReplacements);
+builder.setDefaultNsUri(defaultNsUri);
+builder.setC14NSupport(c14nSupport);
+builder.setAnnotationReader(ar);
+builder.setXmlAccessorFactorySupport(xmlAccessorFactorySupport);
+builder.setAllNillable(allNillable);
+builder.setRetainPropertyInfo(retainPropertyInfo);
+builder.setImprovedXsiTypeHandling(improvedXsiTypeHandling);
+return builder.build();
+}
+/**
+* The API will invoke this method via reflection.
+*/
+public static JAXBContext createContext( String contextPath,
+ClassLoader classLoader, Map<String,Object> properties ) throws JAXBException {
+FinalArrayList<Class> classes = new FinalArrayList<Class>();
+StringTokenizer tokens = new StringTokenizer(contextPath,":");
+List<Class> indexedClasses;
+// at least on of these must be true per package
+boolean foundObjectFactory;
+boolean foundJaxbIndex;
+while(tokens.hasMoreTokens()) {
+foundObjectFactory = foundJaxbIndex = false;
+String pkg = tokens.nextToken();
+// look for ObjectFactory and load it
+final Class<?> o;
+try {
+o = classLoader.loadClass(pkg+".ObjectFactory");
+classes.add(o);
+foundObjectFactory = true;
+} catch (ClassNotFoundException e) {
+// not necessarily an error
+}
+// look for jaxb.index and load the list of classes
+try {
+indexedClasses = loadIndexedClasses(pkg, classLoader);
+} catch (IOException e) {
+//TODO: think about this more
+throw new JAXBException(e);
+}
+if(indexedClasses != null) {
+classes.addAll(indexedClasses);
+foundJaxbIndex = true;
+}
+if( !(foundObjectFactory || foundJaxbIndex) ) {
+throw new JAXBException( Messages.BROKEN_CONTEXTPATH.format(pkg));
+}
+}
+return createContext(classes.toArray(new Class[classes.size()]),properties);
+}
+/**
+* Look for jaxb.index file in the specified package and load it's contents
+*
+* @param pkg package name to search in
+* @param classLoader ClassLoader to search in
+* @return a List of Class objects to load, null if there weren't any
+* @throws IOException if there is an error reading the index file
+* @throws JAXBException if there are any errors in the index file
+*/
+private static List<Class> loadIndexedClasses(String pkg, ClassLoader classLoader) throws IOException, JAXBException {
+final String resource = pkg.replace('.', '/') + "/jaxb.index";
+final InputStream resourceAsStream = classLoader.getResourceAsStream(resource);
+if (resourceAsStream == null) {
+return null;
+}
+BufferedReader in =
+new BufferedReader(new InputStreamReader(resourceAsStream, "UTF-8"));
+try {
+FinalArrayList<Class> classes = new FinalArrayList<Class>();
+String className = in.readLine();
+while (className != null) {
+className = className.trim();
+if (className.startsWith("#") || (className.length() == 0)) {
+className = in.readLine();
+continue;
+}
+if (className.endsWith(".class")) {
+throw new JAXBException(Messages.ILLEGAL_ENTRY.format(className));
+}
+try {
+classes.add(classLoader.loadClass(pkg + '.' + className));
+} catch (ClassNotFoundException e) {
+throw new JAXBException(Messages.ERROR_LOADING_CLASS.format(className, resource),e);
+}
+className = in.readLine();
+}
+return classes;
+} finally {
+in.close();
+}
+}
+public static final String USE_JAXB_PROPERTIES = "_useJAXBProperties";
+}

Mercurial > jdk8-mips64-public > jaxws / file comparison

comparison: src/share/jaxws_classes/com/sun/xml/internal/bind/v2/ContextFactory.java

src/share/jaxws_classes/com/sun/xml/internal/bind/v2/ContextFactory.java