com.sun.tools.xjc.reader.internalizer.Internalizer Maven / Gradle / Ivy
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can obtain
* a copy of the License at https://glassfish.dev.java.net/public/CDDL+GPL.html
* or glassfish/bootstrap/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at glassfish/bootstrap/legal/LICENSE.txt.
* Sun designates this particular file as subject to the "Classpath" exception
* as provided by Sun in the GPL Version 2 section of the License file that
* accompanied this code. If applicable, add the following below the License
* Header, with the fields enclosed by brackets [] replaced by your own
* identifying information: "Portions Copyrighted [year]
* [name of copyright owner]"
*
* Contributor(s):
*
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
package com.sun.tools.xjc.reader.internalizer;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.text.ParseException;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;
import com.sun.istack.SAXParseException2;
import com.sun.istack.NotNull;
import com.sun.istack.Nullable;
import com.sun.tools.xjc.ErrorReceiver;
import com.sun.tools.xjc.reader.Const;
import com.sun.tools.xjc.util.DOMUtils;
import com.sun.xml.bind.v2.util.EditDistance;
import com.sun.xml.xsom.SCD;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXParseException;
/**
* Internalizes external binding declarations.
*
*
* The {@link #transform(DOMForest,boolean)} method is the entry point.
*
* @author
* Kohsuke Kawaguchi ([email protected])
*/
class Internalizer {
private static final XPathFactory xpf = XPathFactory.newInstance();
private final XPath xpath = xpf.newXPath();
/**
* Internalize all <jaxb:bindings> customizations in the given forest.
*
* @return
* if the SCD support is enabled, the return bindings need to be applied
* after schema components are parsed.
* If disabled, the returned binding set will be empty.
* SCDs are only for XML Schema, and doesn't make any sense for other
* schema languages.
*/
static SCDBasedBindingSet transform( DOMForest forest, boolean enableSCD ) {
return new Internalizer( forest, enableSCD ).transform();
}
private Internalizer( DOMForest forest, boolean enableSCD ) {
this.errorHandler = forest.getErrorHandler();
this.forest = forest;
this.enableSCD = enableSCD;
}
/**
* DOMForest object currently being processed.
*/
private final DOMForest forest;
/**
* All errors found during the transformation is sent to this object.
*/
private ErrorReceiver errorHandler;
/**
* If true, the SCD-based target selection is supported.
*/
private boolean enableSCD;
private SCDBasedBindingSet transform() {
// either target nodes are conventional DOM nodes (as per spec),
Map targetNodes = new HashMap();
// ... or it will be schema components by means of SCD (RI extension)
SCDBasedBindingSet scd = new SCDBasedBindingSet(forest);
//
// identify target nodes for all
//
for (Element jaxbBindings : forest.outerMostBindings) {
// initially, the inherited context is itself
buildTargetNodeMap(jaxbBindings, jaxbBindings, null, targetNodes, scd);
}
//
// then move them to their respective positions.
//
for (Element jaxbBindings : forest.outerMostBindings) {
move(jaxbBindings, targetNodes);
}
return scd;
}
/**
* Validates attributes of a <jaxb:bindings> element.
*/
private void validate( Element bindings ) {
NamedNodeMap atts = bindings.getAttributes();
for( int i=0; i node specifies @scd to
* specify the target via SCD, then this parameter represents that context.
*/
private void buildTargetNodeMap( Element bindings, @NotNull Node inheritedTarget,
@Nullable SCDBasedBindingSet.Target inheritedSCD,
Map result, SCDBasedBindingSet scdResult ) {
// start by the inherited target
Node target = inheritedTarget;
validate(bindings); // validate this node
// look for @schemaLocation
if( bindings.getAttributeNode("schemaLocation")!=null ) {
String schemaLocation = bindings.getAttribute("schemaLocation");
try {
// absolutize this URI.
// TODO: use the URI class
// TODO: honor xml:base
schemaLocation = new URL(
new URL( forest.getSystemId(bindings.getOwnerDocument()) ),
schemaLocation ).toExternalForm();
} catch( MalformedURLException e ) {
// continue with the original schemaLocation value
}
target = forest.get(schemaLocation);
if(target==null) {
reportError( bindings,
Messages.format(Messages.ERR_INCORRECT_SCHEMA_REFERENCE,
schemaLocation,
EditDistance.findNearest(schemaLocation,forest.listSystemIDs())));
return; // abort processing this
}
target = ((Document)target).getDocumentElement();
}
// look for @node
if( bindings.getAttributeNode("node")!=null ) {
String nodeXPath = bindings.getAttribute("node");
// evaluate this XPath
NodeList nlst;
try {
xpath.setNamespaceContext(new NamespaceContextImpl(bindings));
nlst = (NodeList)xpath.evaluate(nodeXPath,target,XPathConstants.NODESET);
} catch (XPathExpressionException e) {
reportError( bindings,
Messages.format(Messages.ERR_XPATH_EVAL,e.getMessage()), e );
return; // abort processing this
}
if( nlst.getLength()==0 ) {
reportError( bindings,
Messages.format(Messages.NO_XPATH_EVAL_TO_NO_TARGET, nodeXPath) );
return; // abort
}
if( nlst.getLength()!=1 ) {
reportError( bindings,
Messages.format(Messages.NO_XPATH_EVAL_TOO_MANY_TARGETS, nodeXPath,nlst.getLength()) );
return; // abort
}
Node rnode = nlst.item(0);
if(!(rnode instanceof Element )) {
reportError( bindings,
Messages.format(Messages.NO_XPATH_EVAL_TO_NON_ELEMENT, nodeXPath) );
return; // abort
}
if( !forest.logic.checkIfValidTargetNode(forest,bindings,(Element)rnode) ) {
reportError( bindings,
Messages.format(Messages.XPATH_EVAL_TO_NON_SCHEMA_ELEMENT,
nodeXPath, rnode.getNodeName() ) );
return; // abort
}
target = rnode;
}
// look for @scd
if( bindings.getAttributeNode("scd")!=null ) {
String scdPath = bindings.getAttribute("scd");
if(!enableSCD) {
// SCD selector was found, but it's not activated. report an error
// but recover by handling it anyway. this also avoids repeated error messages.
reportError(bindings,
Messages.format(Messages.SCD_NOT_ENABLED));
enableSCD = true;
}
try {
inheritedSCD = scdResult.createNewTarget( inheritedSCD, bindings,
SCD.create(scdPath, new NamespaceContextImpl(bindings)) );
} catch (ParseException e) {
reportError( bindings, Messages.format(Messages.ERR_SCD_EVAL,e.getMessage()),e );
return; // abort processing this bindings
}
}
// update the result map
if(inheritedSCD!=null)
inheritedSCD.addBinidng(bindings);
else
result.put( bindings, target );
// look for child and process them recursively
Element[] children = DOMUtils.getChildElements( bindings, Const.JAXB_NSURI, "bindings" );
for (Element value : children)
buildTargetNodeMap(value, target, inheritedSCD, result, scdResult);
}
/**
* Moves JAXB customizations under their respective target nodes.
*/
private void move( Element bindings, Map targetNodes ) {
Node target = targetNodes.get(bindings);
if(target==null)
// this must be the result of an error on the external binding.
// recover from the error by ignoring this node
return;
for (Element item : DOMUtils.getChildElements(bindings)) {
String localName = item.getLocalName();
if ("bindings".equals(localName)) {
// process child recursively
move(item, targetNodes);
} else
if ("globalBindings".equals(localName)) {
// always go to the root of document.
moveUnder(item,forest.getOneDocument().getDocumentElement());
} else {
if (!(target instanceof Element)) {
reportError(item,
Messages.format(Messages.CONTEXT_NODE_IS_NOT_ELEMENT));
return; // abort
}
if (!forest.logic.checkIfValidTargetNode(forest, item, (Element)target)) {
reportError(item,
Messages.format(Messages.ORPHANED_CUSTOMIZATION, item.getNodeName()));
return; // abort
}
// move this node under the target
moveUnder(item,(Element)target);
}
}
}
/**
* Moves the "decl" node under the "target" node.
*
* @param decl
* A JAXB customization element (e.g., <jaxb:class>)
*
* @param target
* XML Schema element under which the declaration should move.
* For example, <xs:element>
*/
private void moveUnder( Element decl, Element target ) {
Element realTarget = forest.logic.refineTarget(target);
declExtensionNamespace( decl, target );
// copy in-scope namespace declarations of the decl node
// to the decl node itself so that this move won't change
// the in-scope namespace bindings.
Element p = decl;
Set inscopes = new HashSet();
while(true) {
NamedNodeMap atts = p.getAttributes();
for( int i=0; i
* Note that this method doesn't use the default namespace
* even if it can.
*/
private String allocatePrefix( Element e, String nsUri ) {
// look for existing namespaces.
NamedNodeMap atts = e.getAttributes();
for( int i=0; i