+ * A client must invoke methods in the following order: + *
+ * We use a {@link TreeMap} here so that the suggested names will
+ * be consistent across JVMs.
+ *
+ * @see SchemaOutputResolver#createOutput(String, String)
+ */
+ private final Map
+ * A {@link ClassInfo} may have two namespaces --- one for the element name
+ * and the other for the type name. If they are different, we put the same
+ * {@link ClassInfo} to two {@link Namespace}s.
+ */
+ public void add( ClassInfo
+ * Because multiple properties can name the same global element even if
+ * they have different Java type, the schema generator first needs to
+ * walk through the model and decide what to generate for the given
+ * element declaration.
+ *
+ *
+ * This class represents what will be written, and its {@link #equals(Object)}
+ * method is implemented in such a way that two identical declarations
+ * are considered as the same.
+ */
+ abstract class ElementDeclaration {
+ /**
+ * Returns true if two {@link ElementDeclaration}s are representing
+ * the same schema fragment.
+ */
+ @Override
+ public abstract boolean equals(Object o);
+ @Override
+ public abstract int hashCode();
+
+ /**
+ * Generates the declaration.
+ */
+ public abstract void writeTo(String localName, Schema schema);
+ }
+
+ /**
+ * {@link ElementDeclaration} that refers to a {@link NonElement}.
+ */
+ class ElementWithType extends ElementDeclaration {
+ private final boolean nillable;
+ private final NonElement
+ * For example, {@code relative("http://www.sun.com/abc/def","http://www.sun.com/pqr/stu") => "../abc/def"}
+ *
+ *
+ * This method only works on hierarchical URI's, not opaque URI's (refer to the
+ * java.net.URI
+ * javadoc for complete definitions of these terms.
+ *
+ *
+ * This method will not normalize the relative URI.
+ *
+ * @return the relative URI or the original URI if a relative one could not be computed
+ */
+ protected static String relativize(String uri, String baseUri) {
+ try {
+ assert uri!=null;
+
+ if(baseUri==null) return uri;
+
+ URI theUri = new URI(escapeURI(uri));
+ URI theBaseUri = new URI(escapeURI(baseUri));
+
+ if (theUri.isOpaque() || theBaseUri.isOpaque())
+ return uri;
+
+ if (!equalsIgnoreCase(theUri.getScheme(), theBaseUri.getScheme()) ||
+ !equal(theUri.getAuthority(), theBaseUri.getAuthority()))
+ return uri;
+
+ String uriPath = theUri.getPath();
+ String basePath = theBaseUri.getPath();
+
+ // normalize base path
+ if (!basePath.endsWith("/")) {
+ basePath = normalizeUriPath(basePath);
+ }
+
+ if( uriPath.equals(basePath))
+ return ".";
+
+ String relPath = calculateRelativePath(uriPath, basePath, fixNull(theUri.getScheme()).equals("file"));
+
+ if (relPath == null)
+ return uri; // recursion found no commonality in the two uris at all
+ StringBuilder relUri = new StringBuilder();
+ relUri.append(relPath);
+ if (theUri.getQuery() != null)
+ relUri.append('?').append(theUri.getQuery());
+ if (theUri.getFragment() != null)
+ relUri.append('#').append(theUri.getFragment());
+
+ return relUri.toString();
+ } catch (URISyntaxException e) {
+ throw new InternalError("Error escaping one of these uris:\n\t"+uri+"\n\t"+baseUri);
+ }
+ }
+
+ private static String fixNull(String s) {
+ if(s==null) return "";
+ else return s;
+ }
+
+ private static String calculateRelativePath(String uri, String base, boolean fileUrl) {
+ // if this is a file URL (very likely), and if this is on a case-insensitive file system,
+ // then treat it accordingly.
+ boolean onWindows = File.pathSeparatorChar==';';
+
+ if (base == null) {
+ return null;
+ }
+ if ((fileUrl && onWindows && startsWithIgnoreCase(uri,base)) || uri.startsWith(base)) {
+ return uri.substring(base.length());
+ } else {
+ return "../" + calculateRelativePath(uri, getParentUriPath(base), fileUrl);
+ }
+ }
+
+ private static boolean startsWithIgnoreCase(String s, String t) {
+ return s.toUpperCase().startsWith(t.toUpperCase());
+ }
+
+ /**
+ * JAX-RPC wants the namespaces to be sorted in the reverse order
+ * so that the empty namespace "" comes to the very end. Don't ask me why.
+ */
+ private static final Comparator