org.apache.xmlbeans.impl.schema.StscImporter Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of commons-xmlbeans Show documentation
Show all versions of commons-xmlbeans Show documentation
The Apache Commons Codec package contains simple encoder and decoders for
various formats such as Base64 and Hexadecimal. In addition to these
widely used encoders and decoders, the codec package also maintains a
collection of phonetic encoding utilities.
The newest version!
/* Copyright 2004 The Apache Software Foundation
*
* Licensed 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 org.apache.xmlbeans.impl.schema;
import org.apache.xmlbeans.impl.xb.xsdschema.RedefineDocument.Redefine;
import org.apache.xmlbeans.impl.xb.xsdschema.SchemaDocument.Schema;
import org.apache.xmlbeans.impl.xb.xsdschema.SchemaDocument;
import org.apache.xmlbeans.impl.xb.xsdschema.ImportDocument.Import;
import org.apache.xmlbeans.impl.xb.xsdschema.IncludeDocument.Include;
import java.util.Map;
import java.util.List;
import java.util.LinkedList;
import java.util.Set;
import java.util.HashMap;
import java.util.HashSet;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Arrays;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.MalformedURLException;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.Reader;
import java.io.InputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.CharArrayReader;
import java.io.Writer;
import java.io.CharArrayWriter;
import java.io.OutputStreamWriter;
import org.apache.xmlbeans.XmlObject;
import org.apache.xmlbeans.XmlException;
import org.apache.xmlbeans.XmlOptions;
import org.apache.xmlbeans.SchemaTypeLoader;
import org.apache.xmlbeans.XmlErrorCodes;
import org.apache.xmlbeans.impl.common.IOUtil;
import org.apache.xmlbeans.impl.common.XmlEncodingSniffer;
import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
public class StscImporter
{
public static SchemaToProcess[] resolveImportsAndIncludes(Schema[] startWith, boolean forceSrcSave)
{
DownloadTable engine = new DownloadTable(startWith);
return engine.resolveImportsAndIncludes(forceSrcSave);
}
public static class SchemaToProcess
{
private Schema schema;
private String chameleonNamespace;
private List includes; // list of SchemaToProcess objects directly included by this
private List redefines; // list of SchemaToProcess objects directly redefined by this
private List redefineObjects; // list of Redefine objects associated to each redefinition
private Set indirectIncludes; // set of SchemaToProcess objects directly/indirectly included by this
private Set indirectIncludedBy; // set of SchemaToProcess objects that include this directly/indirectly
public SchemaToProcess(Schema schema, String chameleonNamespace)
{
this.schema = schema;
this.chameleonNamespace = chameleonNamespace;
}
/**
* The schema to parse.
*/
public Schema getSchema()
{
return schema;
}
/**
* The base URI for this stp
*/
public String getSourceName()
{
return schema.documentProperties().getSourceName();
}
/**
* The chameleon namespace. Null if this schema is not being treated
* as a chameleon. (The ordinary targetNamespace will just be extracted
* from the syntax of the schema.)
*/
public String getChameleonNamespace()
{
return chameleonNamespace;
}
/**
* This method and the remaining methods are used to represent a
* directed graph of includes/redefines. This is required in order
* to establish identity component by component, as required in
* xmlschema-1, chapter 4.2.2
* @return
*/
public List getRedefines()
{
return redefines;
}
public List getRedefineObjects()
{
return redefineObjects;
}
private void addInclude(SchemaToProcess include)
{
if (includes == null)
includes = new ArrayList();
includes.add(include);
}
private void addRedefine(SchemaToProcess redefine, Redefine object)
{
if (redefines == null || redefineObjects == null)
{
redefines = new ArrayList();
redefineObjects = new ArrayList();
}
redefines.add(redefine);
redefineObjects.add(object);
}
private void buildIndirectReferences()
{
if (includes != null)
for (int i = 0; i < includes.size(); i++)
{
SchemaToProcess schemaToProcess = (SchemaToProcess) includes.get(i);
/* We have a this-schemaToProcess vertex
* This means that all nodes accessible from schemaToProcess are
* also accessible from this and all nodes that have access to
* this also have access to schemaToProcess */
this.addIndirectIncludes(schemaToProcess);
}
// Repeat the same algorithm for redefines, since redefines are also includes
if (redefines != null)
for (int i = 0; i < redefines.size(); i++)
{
SchemaToProcess schemaToProcess = (SchemaToProcess) redefines.get(i);
this.addIndirectIncludes(schemaToProcess);
}
}
private void addIndirectIncludes(SchemaToProcess schemaToProcess)
{
if (indirectIncludes == null)
indirectIncludes = new HashSet();
indirectIncludes.add(schemaToProcess);
if (schemaToProcess.indirectIncludedBy == null)
schemaToProcess.indirectIncludedBy = new HashSet();
schemaToProcess.indirectIncludedBy.add(this);
addIndirectIncludesHelper(this, schemaToProcess);
if (indirectIncludedBy != null)
for (Iterator it = indirectIncludedBy.iterator(); it.hasNext();)
{
SchemaToProcess stp = (SchemaToProcess) it.next();
stp.indirectIncludes.add(schemaToProcess);
schemaToProcess.indirectIncludedBy.add(stp);
addIndirectIncludesHelper(stp, schemaToProcess);
}
}
private static void addIndirectIncludesHelper(SchemaToProcess including,
SchemaToProcess schemaToProcess)
{
if (schemaToProcess.indirectIncludes != null)
for (Iterator it = schemaToProcess.indirectIncludes.iterator(); it.hasNext();)
{
SchemaToProcess stp = (SchemaToProcess) it.next();
including.indirectIncludes.add(stp);
stp.indirectIncludedBy.add(including);
}
}
public boolean indirectIncludes(SchemaToProcess schemaToProcess)
{
return indirectIncludes != null && indirectIncludes.contains(schemaToProcess);
}
public boolean equals(Object o)
{
if (this == o) return true;
if (!(o instanceof SchemaToProcess)) return false;
final SchemaToProcess schemaToProcess = (SchemaToProcess) o;
if (chameleonNamespace != null ? !chameleonNamespace.equals(schemaToProcess.chameleonNamespace) : schemaToProcess.chameleonNamespace != null) return false;
if (!(schema == schemaToProcess.schema)) return false;
return true;
}
public int hashCode()
{
int result;
result = schema.hashCode();
result = 29 * result + (chameleonNamespace != null ? chameleonNamespace.hashCode() : 0);
return result;
}
}
private final static String PROJECT_URL_PREFIX = "project://local";
private static String baseURLForDoc(XmlObject obj)
{
String path = obj.documentProperties().getSourceName();
if (path == null)
return null;
if (path.startsWith("/"))
return PROJECT_URL_PREFIX + path.replace('\\', '/');
// looks like a URL?
int colon = path.indexOf(':');
if (colon > 1 && path.substring(0, colon).matches("^\\w+$"))
return path;
return PROJECT_URL_PREFIX + "/" + path.replace('\\', '/');
}
private static URI parseURI(String s)
{
if (s == null)
return null;
try
{
return new URI(s);
}
catch (URISyntaxException syntax)
{
return null;
}
}
//workaround for Sun bug # 4723726
public static URI resolve(URI base, String child)
throws URISyntaxException
{
URI childUri = new URI(child);
URI ruri = base.resolve(childUri);
// if the child fragment is relative (which we'll assume is the case
// if URI.resolve doesn't do anything useful with it) and the base
// URI is pointing at something nested inside a jar, we seem to have
// to this ourselves to make sure that the nested jar url gets
// resolved correctly
if (childUri.equals(ruri) && !childUri.isAbsolute() &&
(base.getScheme().equals("jar") || base.getScheme().equals("zip"))) {
String r = base.toString();
int lastslash = r.lastIndexOf('/');
r = r.substring(0,lastslash) + "/" + childUri;
// Sun's implementation of URI doesn't support references to the
// parent directory ("/..") in the part after "!/" so we have to
// remove these ourselves
int exclPointSlashIndex = r.lastIndexOf("!/");
if (exclPointSlashIndex > 0)
{
int slashDotDotIndex = r.indexOf("/..", exclPointSlashIndex);
while (slashDotDotIndex > 0)
{
int prevSlashIndex = r.lastIndexOf("/", slashDotDotIndex - 1);
if (prevSlashIndex >= exclPointSlashIndex)
{
String temp = r.substring(slashDotDotIndex + 3);
r = r.substring(0, prevSlashIndex).concat(temp);
}
slashDotDotIndex = r.indexOf("/..", exclPointSlashIndex);
}
}
return URI.create(r);
}
//fix up normalization bug
if ("file".equals(ruri.getScheme()) && ! child.equals(ruri))
{
if (base.getPath().startsWith("//") && !ruri.getPath().startsWith("//"))
{
String path = "///".concat(ruri.getPath());
try
{
ruri = new URI("file", null, path, ruri.getQuery(), ruri.getFragment());
}
catch(URISyntaxException uris)
{}
}
}
return ruri;
}
public static class DownloadTable
{
/**
* Namespace/schemaLocation pair.
*
* Downloaded schemas are indexed by namespace, schemaLocation, and both.
*
* A perfect match is preferred, but a match-by-namespace is accepted.
* A match-by-schemaLocation is only accepted for includes (not imports).
*/
private static class NsLocPair
{
private String namespaceURI;
private String locationURL;
public NsLocPair(String namespaceURI, String locationURL)
{
this.namespaceURI = namespaceURI;
this.locationURL = locationURL;
}
/**
* Empty string for no-namespace, null for namespace-not-part-of-key
*/
public String getNamespaceURI()
{
return namespaceURI;
}
public String getLocationURL()
{
return locationURL;
}
public boolean equals(Object o)
{
if (this == o) return true;
if (!(o instanceof NsLocPair)) return false;
final NsLocPair nsLocPair = (NsLocPair) o;
if (locationURL != null ? !locationURL.equals(nsLocPair.locationURL) : nsLocPair.locationURL != null) return false;
if (namespaceURI != null ? !namespaceURI.equals(nsLocPair.namespaceURI) : nsLocPair.namespaceURI != null) return false;
return true;
}
public int hashCode()
{
int result;
result = (namespaceURI != null ? namespaceURI.hashCode() : 0);
result = 29 * result + (locationURL != null ? locationURL.hashCode() : 0);
return result;
}
}
private static class DigestKey
{
byte[] _digest;
int _hashCode;
DigestKey(byte[] digest)
{
_digest = digest;
for (int i = 0; i < 4 && i < digest.length; i++)
{
_hashCode = _hashCode << 8;
_hashCode = _hashCode + digest[i];
}
}
public boolean equals(Object o)
{
if (this == o) return true;
if (!(o instanceof DigestKey)) return false;
return Arrays.equals(_digest, ((DigestKey)o)._digest);
}
public int hashCode()
{
return _hashCode;
}
}
private Map schemaByNsLocPair = new HashMap();
private Map schemaByDigestKey = new HashMap();
private LinkedList scanNeeded = new LinkedList();
private Set emptyNamespaceSchemas = new HashSet();
private Map scannedAlready = new HashMap();
private Set failedDownloads = new HashSet();
private Schema downloadSchema(XmlObject referencedBy, String targetNamespace, String locationURL)
{
// no location URL provided? Then nothing to do.
if (locationURL == null)
return null;
StscState state = StscState.get();
// First resolve relative URLs with respect to base URL for doc
URI baseURI = parseURI(baseURLForDoc(referencedBy));
String absoluteURL = null;
try
{
absoluteURL = baseURI == null ? locationURL : resolve(baseURI, locationURL).toString();
}
catch (URISyntaxException e)
{
state.error("Could not find resource - invalid location URL: " + e.getMessage(), XmlErrorCodes.CANNOT_FIND_RESOURCE, referencedBy);
return null;
}
// probe 0: this url is already processed, from a previous compile
if (state.isFileProcessed(absoluteURL))
return null;
// probe 1: ns+url - perfect match
if (absoluteURL != null && targetNamespace != null)
{
Schema result = (Schema)schemaByNsLocPair.get(new NsLocPair(targetNamespace, absoluteURL));
if (result != null)
return result;
}
// probe 2: we have preexisting knowledge of this namespace,
// either from another schema file or from the linker.
// If we're not downloading the given URL, skip it silently if the
// namespace is already represented by a file we have.
// Also, suppress downloads of URLs to namespaces that are already
// known by the linker.
// (We never assume preexisting knowledge of the no-namespace,
// even if we have some definitions, since it's likely that
// more than one person is playing in the no-namespace at once.)
if (targetNamespace != null && !targetNamespace.equals(""))
{
// the URL is not one to download; should we assume we know about the namespace?
if (!state.shouldDownloadURI(absoluteURL))
{
// If we already have a schema representing this namespace,
// then skip this URL silently without producing an error.
Schema result = (Schema)schemaByNsLocPair.get(new NsLocPair(targetNamespace, null));
if (result != null)
return result;
}
// If the linker already knows about this namespace, skip
// this URL.
if (state.linkerDefinesNamespace(targetNamespace))
return null;
}
// probe 3: url only
if (absoluteURL != null)
{
Schema result = (Schema)schemaByNsLocPair.get(new NsLocPair(null, absoluteURL));
if (result != null)
return result;
}
// no match: error if we can't or won't download.
if (absoluteURL == null)
{
state.error("Could not find resource - no valid location URL.", XmlErrorCodes.CANNOT_FIND_RESOURCE, referencedBy);
return null;
}
if (previouslyFailedToDownload(absoluteURL))
{
// an error message has already been produced.
return null;
}
if (!state.shouldDownloadURI(absoluteURL))
{
state.error("Could not load resource \"" + absoluteURL + "\" (network downloads disabled).", XmlErrorCodes.CANNOT_FIND_RESOURCE, referencedBy);
addFailedDownload(absoluteURL);
return null;
}
// try to download
download: try
{
XmlObject xdoc = downloadDocument(state.getS4SLoader(), targetNamespace, absoluteURL);
Schema result = findMatchByDigest(xdoc);
String shortname = state.relativize(absoluteURL);
if (result != null)
{
// if an exactly-the-same document has already been loaded, use the original and spew
String dupname = state.relativize(result.documentProperties().getSourceName());
if (dupname != null)
state.info(shortname + " is the same as " + dupname + " (ignoring the duplicate file)");
else
state.info(shortname + " is the same as another schema");
}
else
{
// otherwise, it's a new document: validate it and grab the contents
XmlOptions voptions = new XmlOptions();
voptions.setErrorListener(state.getErrorListener());
if (!(xdoc instanceof SchemaDocument) || !xdoc.validate(voptions))
{
state.error("Referenced document is not a valid schema", XmlErrorCodes.CANNOT_FIND_RESOURCE, referencedBy);
break download;
}
SchemaDocument sDoc = (SchemaDocument)xdoc;
result = sDoc.getSchema();
state.info("Loading referenced file " + shortname);
}
NsLocPair key = new NsLocPair(emptyStringIfNull(result.getTargetNamespace()), absoluteURL);
addSuccessfulDownload(key, result);
return result;
}
catch (MalformedURLException malformed)
{
state.error("URL \"" + absoluteURL + "\" is not well-formed", XmlErrorCodes.CANNOT_FIND_RESOURCE, referencedBy);
}
catch (IOException connectionProblem)
{
state.error(connectionProblem.toString(), XmlErrorCodes.CANNOT_FIND_RESOURCE, referencedBy);
}
catch (XmlException e)
{
state.error("Problem parsing referenced XML resource - " + e.getMessage(), XmlErrorCodes.CANNOT_FIND_RESOURCE, referencedBy);
}
// record failure so that we don't try to download this URL again
addFailedDownload(absoluteURL);
return null;
}
static XmlObject downloadDocument(SchemaTypeLoader loader, String namespace, String absoluteURL)
throws MalformedURLException, IOException, XmlException
{
StscState state = StscState.get();
EntityResolver resolver = state.getEntityResolver();
if (resolver != null)
{
InputSource source = null;
try
{
source = resolver.resolveEntity(namespace, absoluteURL);
}
catch (SAXException e)
{
throw new XmlException(e);
}
if (source != null)
{
state.addSourceUri(absoluteURL, null);
// first preference for InputSource contract: character stream
Reader reader = source.getCharacterStream();
if (reader != null)
{
reader = copySchemaSource(absoluteURL, reader, state);
XmlOptions options = new XmlOptions();
options.setLoadLineNumbers();
options.setDocumentSourceName(absoluteURL);
return loader.parse(reader, null, options);
}
// second preference for InputSource contract:
InputStream bytes = source.getByteStream();
if (bytes != null)
{
bytes = copySchemaSource(absoluteURL, bytes, state);
String encoding = source.getEncoding();
XmlOptions options = new XmlOptions();
options.setLoadLineNumbers();
options.setLoadMessageDigest();
options.setDocumentSourceName(absoluteURL);
if (encoding != null)
options.setCharacterEncoding(encoding);
return loader.parse(bytes, null, options);
}
// third preference: use the (possibly redirected) url
String urlToLoad = source.getSystemId();
if (urlToLoad == null)
throw new IOException("EntityResolver unable to resolve " + absoluteURL + " (for namespace " + namespace + ")");
copySchemaSource(absoluteURL, state, false);
XmlOptions options = new XmlOptions();
options.setLoadLineNumbers();
options.setLoadMessageDigest();
options.setDocumentSourceName(absoluteURL);
URL urlDownload = new URL(urlToLoad);
return loader.parse(urlDownload, null, options);
}
}
// no resolver - just use the URL directly, no substitution
state.addSourceUri(absoluteURL, null);
copySchemaSource(absoluteURL, state, false);
XmlOptions options = new XmlOptions();
options.setLoadLineNumbers();
options.setLoadMessageDigest();
URL urlDownload = new URL(absoluteURL);
return loader.parse(urlDownload, null, options);
}
private void addSuccessfulDownload(NsLocPair key, Schema schema)
{
byte[] digest = schema.documentProperties().getMessageDigest();
if (digest == null)
{
StscState.get().addSchemaDigest(null);
}
else
{
DigestKey dk = new DigestKey(digest);
if (!schemaByDigestKey.containsKey(dk))
{
schemaByDigestKey.put(new DigestKey(digest), schema);
StscState.get().addSchemaDigest(digest);
}
}
schemaByNsLocPair.put(key, schema);
NsLocPair key1 = new NsLocPair(key.getNamespaceURI(), null);
if (!schemaByNsLocPair.containsKey(key1))
schemaByNsLocPair.put(key1, schema);
NsLocPair key2 = new NsLocPair(null, key.getLocationURL());
if (!schemaByNsLocPair.containsKey(key2))
schemaByNsLocPair.put(key2, schema);
}
private Schema findMatchByDigest(XmlObject original)
{
byte[] digest = original.documentProperties().getMessageDigest();
if (digest == null)
return null;
return (Schema)schemaByDigestKey.get(new DigestKey(digest));
}
private void addFailedDownload(String locationURL)
{
failedDownloads.add(locationURL);
}
private boolean previouslyFailedToDownload(String locationURL)
{
return failedDownloads.contains(locationURL);
}
private static boolean nullableStringsMatch(String s1, String s2)
{
if (s1 == null && s2 == null)
return true;
if (s1 == null || s2 == null)
return false;
return (s1.equals(s2));
}
private static String emptyStringIfNull(String s)
{
if (s == null)
return "";
return s;
}
private SchemaToProcess addScanNeeded(SchemaToProcess stp)
{
if (!scannedAlready.containsKey(stp))
{
scannedAlready.put(stp, stp);
scanNeeded.add(stp);
return stp;
}
else
return (SchemaToProcess) scannedAlready.get(stp);
}
private void addEmptyNamespaceSchema(Schema s)
{
emptyNamespaceSchemas.add(s);
}
private void usedEmptyNamespaceSchema(Schema s)
{
emptyNamespaceSchemas.remove(s);
}
private boolean fetchRemainingEmptyNamespaceSchemas()
{
if (emptyNamespaceSchemas.isEmpty())
return false;
for (Iterator i = emptyNamespaceSchemas.iterator(); i.hasNext();)
{
Schema schema = (Schema)i.next();
addScanNeeded(new SchemaToProcess(schema, null));
}
emptyNamespaceSchemas.clear();
return true;
}
private boolean hasNextToScan()
{
return !scanNeeded.isEmpty();
}
private SchemaToProcess nextToScan()
{
SchemaToProcess next = (SchemaToProcess)scanNeeded.removeFirst();
return next;
}
public DownloadTable(Schema[] startWith)
{
for (int i = 0; i < startWith.length; i++)
{
String targetNamespace = startWith[i].getTargetNamespace();
NsLocPair key = new NsLocPair(targetNamespace, baseURLForDoc(startWith[i]));
addSuccessfulDownload(key, startWith[i]);
if (targetNamespace != null)
addScanNeeded(new SchemaToProcess(startWith[i], null));
else
addEmptyNamespaceSchema(startWith[i]);
}
}
public SchemaToProcess[] resolveImportsAndIncludes(boolean forceSave)
{
StscState state = StscState.get();
List result = new ArrayList();
boolean hasRedefinitions = false;
// algorithm is to scan through each schema document and
// 1. download each import and include (if not already downloaded)
// 2. queue each imported or included schema to be process (if not already queued)
// The algorithm is run twice: first we begin with non-empty
// namespace schemas only. Then we repeat starting with any
// empty empty-namespace schemas that have NOT been chameleon-
// included by other schemas and process them.
for (;;)
{
while (hasNextToScan())
{
SchemaToProcess stp = nextToScan();
String uri = stp.getSourceName();
state.addSourceUri(uri, null);
result.add(stp);
copySchemaSource(uri, state, forceSave);
{
// handle imports
Import[] imports = stp.getSchema().getImportArray();
for (int i = 0; i < imports.length; i++)
{
Schema imported = downloadSchema(imports[i], emptyStringIfNull(imports[i].getNamespace()), imports[i].getSchemaLocation());
// if download fails, an error has already been reported.
if (imported == null)
continue;
if (!nullableStringsMatch(imported.getTargetNamespace(), imports[i].getNamespace()))
{
StscState.get().error("Imported schema has a target namespace \"" + imported.getTargetNamespace() + "\" that does not match the specified \"" + imports[i].getNamespace() + "\"", XmlErrorCodes.MISMATCHED_TARGET_NAMESPACE, imports[i]);
}
else
{
addScanNeeded(new SchemaToProcess(imported, null));
}
}
}
{
// handle includes
Include[] includes = stp.getSchema().getIncludeArray();
String sourceNamespace = stp.getChameleonNamespace();
if (sourceNamespace == null)
sourceNamespace = emptyStringIfNull(stp.getSchema().getTargetNamespace());
for (int i = 0; i < includes.length; i++)
{
Schema included = downloadSchema(includes[i], null, includes[i].getSchemaLocation());
// if download fails, an error has already been reported.
if (included == null)
continue;
if (emptyStringIfNull(included.getTargetNamespace()).equals(sourceNamespace))
{
// non-chameleon case - just like an import
SchemaToProcess s = addScanNeeded(new SchemaToProcess(included, null));
stp.addInclude(s);
}
else if (included.getTargetNamespace() != null)
{
// illegal include: included schema in wrong namespace.
StscState.get().error("Included schema has a target namespace \"" + included.getTargetNamespace() + "\" that does not match the source namespace \"" + sourceNamespace + "\"", XmlErrorCodes.MISMATCHED_TARGET_NAMESPACE, includes[i]);
}
else
{
// chameleon include
SchemaToProcess s = addScanNeeded(new SchemaToProcess(included, sourceNamespace));
stp.addInclude(s);
usedEmptyNamespaceSchema(included);
}
}
}
{
// handle redefines
Redefine[] redefines = stp.getSchema().getRedefineArray();
String sourceNamespace = stp.getChameleonNamespace();
if (sourceNamespace == null)
sourceNamespace = emptyStringIfNull(stp.getSchema().getTargetNamespace());
for (int i = 0; i < redefines.length; i++)
{
Schema redefined = downloadSchema(redefines[i], null, redefines[i].getSchemaLocation());
// if download fails, an error has already been reported.
if (redefined == null)
continue;
if (emptyStringIfNull(redefined.getTargetNamespace()).equals(sourceNamespace))
{
// non-chameleon case
SchemaToProcess s = addScanNeeded(new SchemaToProcess(redefined, null));
stp.addRedefine(s, redefines[i]);
hasRedefinitions = true;
}
else if (redefined.getTargetNamespace() != null)
{
// illegal include: included schema in wrong namespace.
StscState.get().error("Redefined schema has a target namespace \"" + redefined.getTargetNamespace() + "\" that does not match the source namespace \"" + sourceNamespace + "\"", XmlErrorCodes.MISMATCHED_TARGET_NAMESPACE, redefines[i]);
}
else
{
// chameleon redefine
SchemaToProcess s = addScanNeeded(new SchemaToProcess(redefined, sourceNamespace));
stp.addRedefine(s, redefines[i]);
usedEmptyNamespaceSchema(redefined);
hasRedefinitions = true;
}
}
}
}
if (!fetchRemainingEmptyNamespaceSchemas())
break;
}
// Build the lists of indirect references
// Make all the effort only if there are redefinitions
if (hasRedefinitions)
for (int i = 0; i < result.size(); i++)
{
SchemaToProcess schemaToProcess = (SchemaToProcess) result.get(i);
schemaToProcess.buildIndirectReferences();
}
return (SchemaToProcess[])result.toArray(new SchemaToProcess[result.size()]);
}
private static Reader copySchemaSource(String url, Reader reader, StscState state)
{
//Copy the schema file if it wasn't already copied
if (state.getSchemasDir() == null)
return reader;
String schemalocation = state.sourceNameForUri(url);
File targetFile = new File(state.getSchemasDir(), schemalocation);
if (targetFile.exists())
return reader;
try
{
File parentDir = new File(targetFile.getParent());
IOUtil.createDir(parentDir, null);
CharArrayReader car = copy(reader);
XmlEncodingSniffer xes = new XmlEncodingSniffer(car, null);
Writer out = new OutputStreamWriter(new FileOutputStream(targetFile), xes.getXmlEncoding());
IOUtil.copyCompletely(car, out);
car.reset();
return car;
}
catch (IOException e)
{
System.err.println("IO Error " + e);
return reader;
}
}
private static InputStream copySchemaSource(String url, InputStream bytes, StscState state)
{
//Copy the schema file if it wasn't already copied
if (state.getSchemasDir() == null)
return bytes;
String schemalocation = state.sourceNameForUri(url);
File targetFile = new File(state.getSchemasDir(), schemalocation);
if (targetFile.exists())
return bytes;
try
{
File parentDir = new File(targetFile.getParent());
IOUtil.createDir(parentDir, null);
ByteArrayInputStream bais = copy(bytes);
FileOutputStream out = new FileOutputStream(targetFile);
IOUtil.copyCompletely(bais, out);
bais.reset();
return bais;
}
catch (IOException e)
{
System.err.println("IO Error " + e);
return bytes;
}
}
private static void copySchemaSource(String urlLoc, StscState state, boolean forceCopy)
{
//Copy the schema file if it wasn't already copied
if (state.getSchemasDir()!=null)
{
String schemalocation = state.sourceNameForUri(urlLoc);
File targetFile = new File(state.getSchemasDir(), schemalocation);
if (forceCopy || !targetFile.exists())
{
try
{
File parentDir = new File(targetFile.getParent());
IOUtil.createDir(parentDir, null);
InputStream in = null;
URL url = new URL(urlLoc);
// Copy the file from filepath to schema[METADATA_PACKAGE_GEN]/src/
try
{
in = url.openStream();
}
catch (FileNotFoundException fnfe)
{
if (forceCopy && targetFile.exists())
targetFile.delete();
else
throw fnfe;
}
if (in != null)
{
FileOutputStream out = new FileOutputStream(targetFile);
IOUtil.copyCompletely(in, out);
}
}
catch (IOException e)
{
System.err.println("IO Error " + e);
// failure = true; - not cause for failure
}
}
}
}
private static ByteArrayInputStream copy(InputStream is) throws IOException
{
byte [] buf = new byte[1024];
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int bytesRead;
while(( bytesRead = is.read(buf, 0, 1024)) > 0)
baos.write(buf, 0, bytesRead);
return new ByteArrayInputStream(baos.toByteArray());
}
private static CharArrayReader copy(Reader is) throws IOException
{
char[] buf = new char[1024];
CharArrayWriter baos = new CharArrayWriter();
int bytesRead;
while(( bytesRead = is.read(buf, 0, 1024)) > 0)
baos.write(buf, 0, bytesRead);
return new CharArrayReader(baos.toCharArray());
}
}
}