You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@jena.apache.org by an...@apache.org on 2018/05/04 09:03:12 UTC
[11/24] jena git commit: JENA-1537: Remove dependency on Xerces.
Import needed code
http://git-wip-us.apache.org/repos/asf/jena/blob/c9a7e646/jena-core/src/main/java/org/apache/jena/ext/xerces/impl/xs/XSDeclarationPool.java
----------------------------------------------------------------------
diff --git a/jena-core/src/main/java/org/apache/jena/ext/xerces/impl/xs/XSDeclarationPool.java b/jena-core/src/main/java/org/apache/jena/ext/xerces/impl/xs/XSDeclarationPool.java
new file mode 100644
index 0000000..d033a19
--- /dev/null
+++ b/jena-core/src/main/java/org/apache/jena/ext/xerces/impl/xs/XSDeclarationPool.java
@@ -0,0 +1,315 @@
+/*
+ * 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 org.apache.jena.ext.xerces.impl.xs;
+
+import org.apache.jena.ext.xerces.impl.dv.xs.SchemaDVFactoryImpl;
+import org.apache.jena.ext.xerces.impl.dv.xs.XSSimpleTypeDecl;
+
+/**
+ * This class is pool that enables caching of XML Schema declaration objects.
+ * Before a compiled grammar object is garbage collected,
+ * the implementation will add all XML Schema component
+ * declarations to the pool.
+ * Note: The cashing mechanism is not implemented yet.
+ *
+ * @xerces.internal
+ *
+ * @author Elena Litani, IBM
+ * @version $Id: XSDeclarationPool.java 805582 2009-08-18 21:13:20Z sandygao $
+ */
+public final class XSDeclarationPool {
+ /** Chunk shift (8). */
+ private static final int CHUNK_SHIFT = 8; // 2^8 = 256
+
+ /** Chunk size (1 << CHUNK_SHIFT). */
+ private static final int CHUNK_SIZE = 1 << CHUNK_SHIFT;
+
+ /** Chunk mask (CHUNK_SIZE - 1). */
+ private static final int CHUNK_MASK = CHUNK_SIZE - 1;
+
+ /** Initial chunk count (). */
+ private static final int INITIAL_CHUNK_COUNT = (1 << (10 - CHUNK_SHIFT)); // 2^10 = 1k
+//
+// /** Element declaration pool*/
+// private XSElementDecl fElementDecl[][] = new XSElementDecl[INITIAL_CHUNK_COUNT][];
+// private int fElementDeclIndex = 0;
+//
+// /** Particle declaration pool */
+// private XSParticleDecl fParticleDecl[][] = new XSParticleDecl[INITIAL_CHUNK_COUNT][];
+// private int fParticleDeclIndex = 0;
+//
+// /** Particle declaration pool */
+// private XSModelGroupImpl fModelGroup[][] = new XSModelGroupImpl[INITIAL_CHUNK_COUNT][];
+// private int fModelGroupIndex = 0;
+//
+// /** Attribute declaration pool */
+// private XSAttributeDecl fAttrDecl[][] = new XSAttributeDecl[INITIAL_CHUNK_COUNT][];
+// private int fAttrDeclIndex = 0;
+//
+// /** ComplexType declaration pool */
+// private XSComplexTypeDecl fCTDecl[][] = new XSComplexTypeDecl[INITIAL_CHUNK_COUNT][];
+// private int fCTDeclIndex = 0;
+//
+ /** SimpleType declaration pool */
+ private XSSimpleTypeDecl fSTDecl[][] = new XSSimpleTypeDecl[INITIAL_CHUNK_COUNT][];
+ private int fSTDeclIndex = 0;
+//
+// /** AttributeUse declaration pool */
+// private XSAttributeUseImpl fAttributeUse[][] = new XSAttributeUseImpl[INITIAL_CHUNK_COUNT][];
+// private int fAttributeUseIndex = 0;
+//
+ private SchemaDVFactoryImpl dvFactory;
+ public void setDVFactory(SchemaDVFactoryImpl dvFactory) {
+ this.dvFactory = dvFactory;
+ }
+//
+// public final XSElementDecl getElementDecl(){
+// int chunk = fElementDeclIndex >> CHUNK_SHIFT;
+// int index = fElementDeclIndex & CHUNK_MASK;
+// ensureElementDeclCapacity(chunk);
+// if (fElementDecl[chunk][index] == null) {
+// fElementDecl[chunk][index] = new XSElementDecl();
+// } else {
+// fElementDecl[chunk][index].reset();
+// }
+// fElementDeclIndex++;
+// return fElementDecl[chunk][index];
+// }
+//
+// public final XSAttributeDecl getAttributeDecl(){
+// int chunk = fAttrDeclIndex >> CHUNK_SHIFT;
+// int index = fAttrDeclIndex & CHUNK_MASK;
+// ensureAttrDeclCapacity(chunk);
+// if (fAttrDecl[chunk][index] == null) {
+// fAttrDecl[chunk][index] = new XSAttributeDecl();
+// } else {
+// fAttrDecl[chunk][index].reset();
+// }
+// fAttrDeclIndex++;
+// return fAttrDecl[chunk][index];
+//
+// }
+//
+// public final XSAttributeUseImpl getAttributeUse(){
+// int chunk = fAttributeUseIndex >> CHUNK_SHIFT;
+// int index = fAttributeUseIndex & CHUNK_MASK;
+// ensureAttributeUseCapacity(chunk);
+// if (fAttributeUse[chunk][index] == null) {
+// fAttributeUse[chunk][index] = new XSAttributeUseImpl();
+// } else {
+// fAttributeUse[chunk][index].reset();
+// }
+// fAttributeUseIndex++;
+// return fAttributeUse[chunk][index];
+//
+// }
+//
+// public final XSComplexTypeDecl getComplexTypeDecl(){
+// int chunk = fCTDeclIndex >> CHUNK_SHIFT;
+// int index = fCTDeclIndex & CHUNK_MASK;
+// ensureCTDeclCapacity(chunk);
+// if (fCTDecl[chunk][index] == null) {
+//
+// fCTDecl[chunk][index] = new XSComplexTypeDecl();
+// } else {
+// fCTDecl[chunk][index].reset();
+// }
+// fCTDeclIndex++;
+// return fCTDecl[chunk][index];
+// }
+//
+ public final XSSimpleTypeDecl getSimpleTypeDecl(){
+ int chunk = fSTDeclIndex >> CHUNK_SHIFT;
+ int index = fSTDeclIndex & CHUNK_MASK;
+ ensureSTDeclCapacity(chunk);
+ if (fSTDecl[chunk][index] == null) {
+ fSTDecl[chunk][index] = dvFactory.newXSSimpleTypeDecl();
+ } else {
+ fSTDecl[chunk][index].reset();
+ }
+ fSTDeclIndex++;
+ return fSTDecl[chunk][index];
+
+ }
+//
+// public final XSParticleDecl getParticleDecl(){
+// int chunk = fParticleDeclIndex >> CHUNK_SHIFT;
+// int index = fParticleDeclIndex & CHUNK_MASK;
+// ensureParticleDeclCapacity(chunk);
+// if (fParticleDecl[chunk][index] == null) {
+// fParticleDecl[chunk][index] = new XSParticleDecl();
+// } else {
+// fParticleDecl[chunk][index].reset();
+// }
+// fParticleDeclIndex++;
+// return fParticleDecl[chunk][index];
+// }
+//
+// public final XSModelGroupImpl getModelGroup(){
+// int chunk = fModelGroupIndex >> CHUNK_SHIFT;
+// int index = fModelGroupIndex & CHUNK_MASK;
+// ensureModelGroupCapacity(chunk);
+// if (fModelGroup[chunk][index] == null) {
+// fModelGroup[chunk][index] = new XSModelGroupImpl();
+// } else {
+// fModelGroup[chunk][index].reset();
+// }
+// fModelGroupIndex++;
+// return fModelGroup[chunk][index];
+// }
+//
+// // REVISIT: do we need decl pool for group declarations, attribute group,
+// // notations?
+// // it seems like each schema would use a small number of those
+// // components, so it probably is not worth keeping those components
+// // in the pool.
+//
+// private boolean ensureElementDeclCapacity(int chunk) {
+// if (chunk >= fElementDecl.length) {
+// fElementDecl = resize(fElementDecl, fElementDecl.length * 2);
+// } else if (fElementDecl[chunk] != null) {
+// return false;
+// }
+//
+// fElementDecl[chunk] = new XSElementDecl[CHUNK_SIZE];
+// return true;
+// }
+//
+// private static XSElementDecl[][] resize(XSElementDecl array[][], int newsize) {
+// XSElementDecl newarray[][] = new XSElementDecl[newsize][];
+// System.arraycopy(array, 0, newarray, 0, array.length);
+// return newarray;
+// }
+//
+// private boolean ensureParticleDeclCapacity(int chunk) {
+// if (chunk >= fParticleDecl.length) {
+// fParticleDecl = resize(fParticleDecl, fParticleDecl.length * 2);
+// } else if (fParticleDecl[chunk] != null) {
+// return false;
+// }
+//
+// fParticleDecl[chunk] = new XSParticleDecl[CHUNK_SIZE];
+// return true;
+// }
+//
+// private boolean ensureModelGroupCapacity(int chunk) {
+// if (chunk >= fModelGroup.length) {
+// fModelGroup = resize(fModelGroup, fModelGroup.length * 2);
+// } else if (fModelGroup[chunk] != null) {
+// return false;
+// }
+//
+// fModelGroup[chunk] = new XSModelGroupImpl[CHUNK_SIZE];
+// return true;
+// }
+//
+// private static XSParticleDecl[][] resize(XSParticleDecl array[][], int newsize) {
+// XSParticleDecl newarray[][] = new XSParticleDecl[newsize][];
+// System.arraycopy(array, 0, newarray, 0, array.length);
+// return newarray;
+// }
+//
+// private static XSModelGroupImpl[][] resize(XSModelGroupImpl array[][], int newsize) {
+// XSModelGroupImpl newarray[][] = new XSModelGroupImpl[newsize][];
+// System.arraycopy(array, 0, newarray, 0, array.length);
+// return newarray;
+// }
+//
+// private boolean ensureAttrDeclCapacity(int chunk) {
+// if (chunk >= fAttrDecl.length) {
+// fAttrDecl = resize(fAttrDecl, fAttrDecl.length * 2);
+// } else if (fAttrDecl[chunk] != null) {
+// return false;
+// }
+//
+// fAttrDecl[chunk] = new XSAttributeDecl[CHUNK_SIZE];
+// return true;
+// }
+//
+// private static XSAttributeDecl[][] resize(XSAttributeDecl array[][], int newsize) {
+// XSAttributeDecl newarray[][] = new XSAttributeDecl[newsize][];
+// System.arraycopy(array, 0, newarray, 0, array.length);
+// return newarray;
+// }
+//
+// private boolean ensureAttributeUseCapacity(int chunk) {
+// if (chunk >= fAttributeUse.length) {
+// fAttributeUse = resize(fAttributeUse, fAttributeUse.length * 2);
+// } else if (fAttributeUse[chunk] != null) {
+// return false;
+// }
+//
+// fAttributeUse[chunk] = new XSAttributeUseImpl[CHUNK_SIZE];
+// return true;
+// }
+//
+// private static XSAttributeUseImpl[][] resize(XSAttributeUseImpl array[][], int newsize) {
+// XSAttributeUseImpl newarray[][] = new XSAttributeUseImpl[newsize][];
+// System.arraycopy(array, 0, newarray, 0, array.length);
+// return newarray;
+// }
+//
+ private boolean ensureSTDeclCapacity(int chunk) {
+ if (chunk >= fSTDecl.length) {
+ fSTDecl = resize(fSTDecl, fSTDecl.length * 2);
+ } else if (fSTDecl[chunk] != null) {
+ return false;
+ }
+
+ fSTDecl[chunk] = new XSSimpleTypeDecl[CHUNK_SIZE];
+ return true;
+ }
+
+ private static XSSimpleTypeDecl[][] resize(XSSimpleTypeDecl array[][], int newsize) {
+ XSSimpleTypeDecl newarray[][] = new XSSimpleTypeDecl[newsize][];
+ System.arraycopy(array, 0, newarray, 0, array.length);
+ return newarray;
+ }
+//
+// private boolean ensureCTDeclCapacity(int chunk) {
+//
+// if (chunk >= fCTDecl.length) {
+// fCTDecl = resize(fCTDecl, fCTDecl.length * 2);
+// } else if (fCTDecl[chunk] != null){
+// return false;
+// }
+//
+// fCTDecl[chunk] = new XSComplexTypeDecl[CHUNK_SIZE];
+// return true;
+// }
+//
+// private static XSComplexTypeDecl[][] resize(XSComplexTypeDecl array[][], int newsize) {
+// XSComplexTypeDecl newarray[][] = new XSComplexTypeDecl[newsize][];
+// System.arraycopy(array, 0, newarray, 0, array.length);
+// return newarray;
+// }
+//
+//
+//
+ public void reset(){
+// fElementDeclIndex = 0;
+// fParticleDeclIndex = 0;
+// fModelGroupIndex = 0;
+ fSTDeclIndex = 0;
+// fCTDeclIndex = 0;
+// fAttrDeclIndex = 0;
+// fAttributeUseIndex = 0;
+ }
+//
+//
+}
http://git-wip-us.apache.org/repos/asf/jena/blob/c9a7e646/jena-core/src/main/java/org/apache/jena/ext/xerces/impl/xs/util/ObjectListImpl.java
----------------------------------------------------------------------
diff --git a/jena-core/src/main/java/org/apache/jena/ext/xerces/impl/xs/util/ObjectListImpl.java b/jena-core/src/main/java/org/apache/jena/ext/xerces/impl/xs/util/ObjectListImpl.java
new file mode 100644
index 0000000..062f397
--- /dev/null
+++ b/jena-core/src/main/java/org/apache/jena/ext/xerces/impl/xs/util/ObjectListImpl.java
@@ -0,0 +1,123 @@
+/*
+ * 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 org.apache.jena.ext.xerces.impl.xs.util;
+
+import java.lang.reflect.Array;
+import java.util.AbstractList;
+
+import org.apache.jena.ext.xerces.xs.datatypes.ObjectList;
+
+/**
+ * Contains a list of Objects.
+ *
+ * @xerces.internal
+ *
+ * @version $Id: ObjectListImpl.java 789785 2009-06-30 15:10:26Z knoaman $
+ */
+@SuppressWarnings("all")
+public final class ObjectListImpl extends AbstractList<Object> implements ObjectList {
+
+ /**
+ * An immutable empty list.
+ */
+ public static final ObjectListImpl EMPTY_LIST = new ObjectListImpl(new Object[0], 0);
+
+ // The array to hold all data
+ private final Object[] fArray;
+
+ // Number of elements in this list
+ private final int fLength;
+
+ public ObjectListImpl(Object[] array, int length) {
+ fArray = array;
+ fLength = length;
+ }
+
+ @Override
+ public int getLength() {
+ return fLength;
+ }
+
+ @Override
+ public boolean contains(Object item) {
+ if (item == null) {
+ for (int i = 0; i < fLength; i++) {
+ if (fArray[i] == null)
+ return true;
+ }
+ }
+ else {
+ for (int i = 0; i < fLength; i++) {
+ if (item.equals(fArray[i]))
+ return true;
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public Object item(int index) {
+ if (index < 0 || index >= fLength) {
+ return null;
+ }
+ return fArray[index];
+ }
+
+ /*
+ * List methods
+ */
+ @Override
+ public Object get(int index) {
+ if (index >= 0 && index < fLength) {
+ return fArray[index];
+ }
+ throw new IndexOutOfBoundsException("Index: " + index);
+ }
+
+ @Override
+ public int size() {
+ return getLength();
+ }
+
+ @Override
+ public Object[] toArray() {
+ Object[] a = new Object[fLength];
+ toArray0(a);
+ return a;
+ }
+
+ @Override
+ public Object[] toArray(Object[] a) {
+ if (a.length < fLength) {
+ Class arrayClass = a.getClass();
+ Class componentType = arrayClass.getComponentType();
+ a = (Object[]) Array.newInstance(componentType, fLength);
+ }
+ toArray0(a);
+ if (a.length > fLength) {
+ a[fLength] = null;
+ }
+ return a;
+ }
+
+ private void toArray0(Object[] a) {
+ if (fLength > 0) {
+ System.arraycopy(fArray, 0, a, 0, fLength);
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/jena/blob/c9a7e646/jena-core/src/main/java/org/apache/jena/ext/xerces/impl/xs/util/ShortListImpl.java
----------------------------------------------------------------------
diff --git a/jena-core/src/main/java/org/apache/jena/ext/xerces/impl/xs/util/ShortListImpl.java b/jena-core/src/main/java/org/apache/jena/ext/xerces/impl/xs/util/ShortListImpl.java
new file mode 100644
index 0000000..8479915
--- /dev/null
+++ b/jena-core/src/main/java/org/apache/jena/ext/xerces/impl/xs/util/ShortListImpl.java
@@ -0,0 +1,128 @@
+/*
+ * 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 org.apache.jena.ext.xerces.impl.xs.util;
+
+import java.util.AbstractList;
+
+import org.apache.jena.ext.xerces.xs.ShortList;
+import org.apache.jena.ext.xerces.xs.XSException;
+
+/**
+ * Contains a list of shorts.
+ *
+ * @xerces.internal
+ *
+ * @author Sandy Gao, IBM
+ *
+ * @version $Id: ShortListImpl.java 725840 2008-12-11 22:19:06Z mrglavas $
+ */
+@SuppressWarnings("all")
+public final class ShortListImpl extends AbstractList implements ShortList {
+
+ /**
+ * An immutable empty list.
+ */
+ public static final ShortListImpl EMPTY_LIST = new ShortListImpl(new short[0], 0);
+
+ // The array to hold all data
+ private final short[] fArray;
+ // Number of elements in this list
+ private final int fLength;
+
+ /**
+ * Construct an XSObjectList implementation
+ *
+ * @param array the data array
+ * @param length the number of elements
+ */
+ public ShortListImpl(short[] array, int length) {
+ fArray = array;
+ fLength = length;
+ }
+
+ /**
+ * The number of <code>Objects</code> in the list. The range of valid
+ * child node indices is 0 to <code>length-1</code> inclusive.
+ */
+ @Override
+ public int getLength() {
+ return fLength;
+ }
+
+ /**
+ * Checks if the <code>unsigned short</code> <code>item</code> is a
+ * member of this list.
+ * @param item <code>unsigned short</code> whose presence in this list
+ * is to be tested.
+ * @return True if this list contains the <code>unsigned short</code>
+ * <code>item</code>.
+ */
+ @Override
+ public boolean contains(short item) {
+ for (int i = 0; i < fLength; i++) {
+ if (fArray[i] == item) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public short item(int index) throws XSException {
+ if (index < 0 || index >= fLength) {
+ throw new XSException(XSException.INDEX_SIZE_ERR, null);
+ }
+ return fArray[index];
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == null || !(obj instanceof ShortList)) {
+ return false;
+ }
+ ShortList rhs = (ShortList)obj;
+
+ if (fLength != rhs.getLength()) {
+ return false;
+ }
+ for (int i = 0;i < fLength; ++i) {
+ if (fArray[i] != rhs.item(i)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /*
+ * List methods
+ */
+
+ @Override
+ public Object get(int index) {
+ if (index >= 0 && index < fLength) {
+ return new Short(fArray[index]);
+ }
+ throw new IndexOutOfBoundsException("Index: " + index);
+ }
+
+ @Override
+ public int size() {
+ return getLength();
+ }
+
+} // class ShortListImpl
http://git-wip-us.apache.org/repos/asf/jena/blob/c9a7e646/jena-core/src/main/java/org/apache/jena/ext/xerces/impl/xs/util/StringListImpl.java
----------------------------------------------------------------------
diff --git a/jena-core/src/main/java/org/apache/jena/ext/xerces/impl/xs/util/StringListImpl.java b/jena-core/src/main/java/org/apache/jena/ext/xerces/impl/xs/util/StringListImpl.java
new file mode 100644
index 0000000..81a7916
--- /dev/null
+++ b/jena-core/src/main/java/org/apache/jena/ext/xerces/impl/xs/util/StringListImpl.java
@@ -0,0 +1,171 @@
+/*
+ * 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 org.apache.jena.ext.xerces.impl.xs.util;
+
+import java.lang.reflect.Array;
+import java.util.AbstractList;
+import java.util.Vector;
+
+import org.apache.jena.ext.xerces.xs.StringList;
+
+/**
+ * Contains a list of Strings.
+ *
+ * @xerces.internal
+ *
+ * @author Sandy Gao, IBM
+ *
+ * @version $Id: StringListImpl.java 776326 2009-05-19 14:27:24Z mrglavas $
+ */
+@SuppressWarnings("all")
+public final class StringListImpl extends AbstractList implements StringList {
+
+ /**
+ * An immutable empty list.
+ */
+ public static final StringListImpl EMPTY_LIST = new StringListImpl(new String[0], 0);
+
+ // The array to hold all data
+ private final String[] fArray;
+ // Number of elements in this list
+ private final int fLength;
+
+ // REVISIT: this is temp solution. In general we need to use this class
+ // instead of the Vector.
+ private final Vector fVector;
+
+ public StringListImpl(Vector v) {
+ fVector = v;
+ fLength = (v == null) ? 0 : v.size();
+ fArray = null;
+ }
+
+ /**
+ * Construct an XSObjectList implementation
+ *
+ * @param array the data array
+ * @param length the number of elements
+ */
+ public StringListImpl(String[] array, int length) {
+ fArray = array;
+ fLength = length;
+ fVector = null;
+ }
+
+ /**
+ * The number of <code>Objects</code> in the list. The range of valid
+ * child node indices is 0 to <code>length-1</code> inclusive.
+ */
+ @Override
+ public int getLength() {
+ return fLength;
+ }
+
+ /**
+ * Checks if the <code>GenericString</code> <code>item</code> is a member
+ * of this list.
+ * @param item <code>GenericString</code> whose presence in this list is
+ * to be tested.
+ * @return True if this list contains the <code>GenericString</code>
+ * <code>item</code>.
+ */
+ @Override
+ public boolean contains(String item) {
+ if (fVector != null) {
+ return fVector.contains(item);
+ }
+ if (item == null) {
+ for (int i = 0; i < fLength; i++) {
+ if (fArray[i] == null)
+ return true;
+ }
+ }
+ else {
+ for (int i = 0; i < fLength; i++) {
+ if (item.equals(fArray[i]))
+ return true;
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public String item(int index) {
+ if (index < 0 || index >= fLength) {
+ return null;
+ }
+ if (fVector != null) {
+ return (String)fVector.elementAt(index);
+ }
+ return fArray[index];
+ }
+
+ /*
+ * List methods
+ */
+
+ @Override
+ public Object get(int index) {
+ if (index >= 0 && index < fLength) {
+ if (fVector != null) {
+ return fVector.elementAt(index);
+ }
+ return fArray[index];
+ }
+ throw new IndexOutOfBoundsException("Index: " + index);
+ }
+
+ @Override
+ public int size() {
+ return getLength();
+ }
+
+ @Override
+ public Object[] toArray() {
+ if (fVector != null) {
+ return fVector.toArray();
+ }
+ Object[] a = new Object[fLength];
+ toArray0(a);
+ return a;
+ }
+
+ @Override
+ public Object[] toArray(Object[] a) {
+ if (fVector != null) {
+ return fVector.toArray(a);
+ }
+ if (a.length < fLength) {
+ Class arrayClass = a.getClass();
+ Class componentType = arrayClass.getComponentType();
+ a = (Object[]) Array.newInstance(componentType, fLength);
+ }
+ toArray0(a);
+ if (a.length > fLength) {
+ a[fLength] = null;
+ }
+ return a;
+ }
+
+ private void toArray0(Object[] a) {
+ if (fLength > 0) {
+ System.arraycopy(fArray, 0, a, 0, fLength);
+ }
+ }
+
+} // class StringListImpl
http://git-wip-us.apache.org/repos/asf/jena/blob/c9a7e646/jena-core/src/main/java/org/apache/jena/ext/xerces/impl/xs/util/XSObjectListImpl.java
----------------------------------------------------------------------
diff --git a/jena-core/src/main/java/org/apache/jena/ext/xerces/impl/xs/util/XSObjectListImpl.java b/jena-core/src/main/java/org/apache/jena/ext/xerces/impl/xs/util/XSObjectListImpl.java
new file mode 100644
index 0000000..22bc47b
--- /dev/null
+++ b/jena-core/src/main/java/org/apache/jena/ext/xerces/impl/xs/util/XSObjectListImpl.java
@@ -0,0 +1,293 @@
+/*
+ * 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 org.apache.jena.ext.xerces.impl.xs.util;
+
+import java.lang.reflect.Array;
+import java.util.AbstractList;
+import java.util.Iterator;
+import java.util.ListIterator;
+import java.util.NoSuchElementException;
+
+import org.apache.jena.ext.xerces.xs.XSObject;
+import org.apache.jena.ext.xerces.xs.XSObjectList;
+
+/**
+ * Contains a list of XSObjects.
+ *
+ * @xerces.internal
+ *
+ * @author Sandy Gao, IBM
+ *
+ * @version $Id: XSObjectListImpl.java 776079 2009-05-18 20:22:27Z mrglavas $
+ */
+@SuppressWarnings("all")
+public class XSObjectListImpl extends AbstractList implements XSObjectList {
+
+ /**
+ * An immutable empty list.
+ */
+ public static final XSObjectListImpl EMPTY_LIST = new XSObjectListImpl(new XSObject[0], 0);
+ private static final ListIterator EMPTY_ITERATOR = new ListIterator() {
+ @Override
+ public boolean hasNext() {
+ return false;
+ }
+ @Override
+ public Object next() {
+ throw new NoSuchElementException();
+ }
+ @Override
+ public boolean hasPrevious() {
+ return false;
+ }
+ @Override
+ public Object previous() {
+ throw new NoSuchElementException();
+ }
+ @Override
+ public int nextIndex() {
+ return 0;
+ }
+ @Override
+ public int previousIndex() {
+ return -1;
+ }
+ @Override
+ public void remove() {
+ throw new UnsupportedOperationException();
+ }
+ @Override
+ public void set(Object object) {
+ throw new UnsupportedOperationException();
+ }
+ @Override
+ public void add(Object object) {
+ throw new UnsupportedOperationException();
+ }
+ };
+
+ private static final int DEFAULT_SIZE = 4;
+
+ // The array to hold all data
+ private XSObject[] fArray = null;
+ // Number of elements in this list
+ private int fLength = 0;
+
+ public XSObjectListImpl() {
+ fArray = new XSObject[DEFAULT_SIZE];
+ fLength = 0;
+ }
+
+ /**
+ * Construct an XSObjectList implementation
+ *
+ * @param array the data array
+ * @param length the number of elements
+ */
+ public XSObjectListImpl(XSObject[] array, int length) {
+ fArray = array;
+ fLength = length;
+ }
+
+ /**
+ * The number of <code>XSObjects</code> in the list. The range of valid
+ * child node indices is 0 to <code>length-1</code> inclusive.
+ */
+ @Override
+ public int getLength() {
+ return fLength;
+ }
+
+ /**
+ * Returns the <code>index</code>th item in the collection. The index
+ * starts at 0. If <code>index</code> is greater than or equal to the
+ * number of nodes in the list, this returns <code>null</code>.
+ * @param index index into the collection.
+ * @return The XSObject at the <code>index</code>th position in the
+ * <code>XSObjectList</code>, or <code>null</code> if that is not a
+ * valid index.
+ */
+ @Override
+ public XSObject item(int index) {
+ if (index < 0 || index >= fLength) {
+ return null;
+ }
+ return fArray[index];
+ }
+
+ // clear this object
+ public void clearXSObjectList() {
+ for (int i=0; i<fLength; i++) {
+ fArray[i] = null;
+ }
+ fArray = null;
+ fLength = 0;
+ }
+
+ public void addXSObject(XSObject object) {
+ if (fLength == fArray.length) {
+ XSObject[] temp = new XSObject[fLength + 4];
+ System.arraycopy(fArray, 0, temp, 0, fLength);
+ fArray = temp;
+ }
+ fArray[fLength++] = object;
+ }
+
+ public void addXSObject(int index, XSObject object) {
+ fArray[index] = object;
+ }
+
+ /*
+ * List methods
+ */
+
+ @Override
+ public boolean contains(Object value) {
+ return (value == null) ? containsNull() : containsObject(value);
+ }
+
+ @Override
+ public Object get(int index) {
+ if (index >= 0 && index < fLength) {
+ return fArray[index];
+ }
+ throw new IndexOutOfBoundsException("Index: " + index);
+ }
+
+ @Override
+ public int size() {
+ return getLength();
+ }
+
+ @Override
+ public Iterator iterator() {
+ return listIterator0(0);
+ }
+
+ @Override
+ public ListIterator listIterator() {
+ return listIterator0(0);
+ }
+
+ @Override
+ public ListIterator listIterator(int index) {
+ if (index >= 0 && index < fLength) {
+ return listIterator0(index);
+ }
+ throw new IndexOutOfBoundsException("Index: " + index);
+ }
+
+ private ListIterator listIterator0(int index) {
+ return fLength == 0 ? EMPTY_ITERATOR : new XSObjectListIterator(index);
+ }
+
+ private boolean containsObject(Object value) {
+ for (int i = fLength - 1; i >= 0; --i) {
+ if (value.equals(fArray[i])) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private boolean containsNull() {
+ for (int i = fLength - 1; i >= 0; --i) {
+ if (fArray[i] == null) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public Object[] toArray() {
+ Object[] a = new Object[fLength];
+ toArray0(a);
+ return a;
+ }
+
+ @Override
+ public Object[] toArray(Object[] a) {
+ if (a.length < fLength) {
+ Class arrayClass = a.getClass();
+ Class componentType = arrayClass.getComponentType();
+ a = (Object[]) Array.newInstance(componentType, fLength);
+ }
+ toArray0(a);
+ if (a.length > fLength) {
+ a[fLength] = null;
+ }
+ return a;
+ }
+
+ private void toArray0(Object[] a) {
+ if (fLength > 0) {
+ System.arraycopy(fArray, 0, a, 0, fLength);
+ }
+ }
+
+ private final class XSObjectListIterator implements ListIterator {
+ private int index;
+ public XSObjectListIterator(int index) {
+ this.index = index;
+ }
+ @Override
+ public boolean hasNext() {
+ return (index < fLength);
+ }
+ @Override
+ public Object next() {
+ if (index < fLength) {
+ return fArray[index++];
+ }
+ throw new NoSuchElementException();
+ }
+ @Override
+ public boolean hasPrevious() {
+ return (index > 0);
+ }
+ @Override
+ public Object previous() {
+ if (index > 0) {
+ return fArray[--index];
+ }
+ throw new NoSuchElementException();
+ }
+ @Override
+ public int nextIndex() {
+ return index;
+ }
+ @Override
+ public int previousIndex() {
+ return index - 1;
+ }
+ @Override
+ public void remove() {
+ throw new UnsupportedOperationException();
+ }
+ @Override
+ public void set(Object o) {
+ throw new UnsupportedOperationException();
+ }
+ @Override
+ public void add(Object o) {
+ throw new UnsupportedOperationException();
+ }
+ }
+
+} // class XSObjectListImpl
http://git-wip-us.apache.org/repos/asf/jena/blob/c9a7e646/jena-core/src/main/java/org/apache/jena/ext/xerces/jaxp/datatype/DatatypeFactoryImpl.java
----------------------------------------------------------------------
diff --git a/jena-core/src/main/java/org/apache/jena/ext/xerces/jaxp/datatype/DatatypeFactoryImpl.java b/jena-core/src/main/java/org/apache/jena/ext/xerces/jaxp/datatype/DatatypeFactoryImpl.java
new file mode 100644
index 0000000..4d26668
--- /dev/null
+++ b/jena-core/src/main/java/org/apache/jena/ext/xerces/jaxp/datatype/DatatypeFactoryImpl.java
@@ -0,0 +1,394 @@
+/*
+ * 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 org.apache.jena.ext.xerces.jaxp.datatype;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.GregorianCalendar;
+
+import javax.xml.datatype.DatatypeConfigurationException;
+import javax.xml.datatype.DatatypeConstants;
+import javax.xml.datatype.DatatypeFactory;
+import javax.xml.datatype.Duration;
+import javax.xml.datatype.XMLGregorianCalendar;
+
+// This is nolonger in the services/javax.xml.datatype.DatatypeFactory file.
+/**
+ * <p>Factory that creates new <code>javax.xml.datatype</code> <code>Object</code>s that map XML to/from Java <code>Object</code>s.</p>
+ *
+ * <p id="DatatypeFactory.newInstance">{@link #newInstance()} is used to create a new <code>DatatypeFactory</code>.
+ * The following implementation resolution mechanisms are used in the following order:</p>
+ * <ol>
+ * <li>
+ * If the system property specified by {@link #DATATYPEFACTORY_PROPERTY}, "<code>javax.xml.datatype.DatatypeFactory</code>",
+ * exists, a class with the name of the property's value is instantiated.
+ * Any Exception thrown during the instantiation process is wrapped as a {@link DatatypeConfigurationException}.
+ * </li>
+ * <li>
+ * If the file ${JAVA_HOME}/lib/jaxp.properties exists, it is loaded in a {@link java.util.Properties} <code>Object</code>.
+ * The <code>Properties</code> <code>Object </code> is then queried for the property as documented in the prior step
+ * and processed as documented in the prior step.
+ * </li>
+ * <li>
+ * The services resolution mechanism is used, e.g. <code>META-INF/services/java.xml.datatype.DatatypeFactory</code>.
+ * Any Exception thrown during the instantiation process is wrapped as a {@link DatatypeConfigurationException}.
+ * </li>
+ * <li>
+ * The final mechanism is to attempt to instantiate the <code>Class</code> specified by
+ * {@link #DATATYPEFACTORY_IMPLEMENTATION_CLASS}, "<code>javax.xml.datatype.DatatypeFactoryImpl</code>".
+ * Any Exception thrown during the instantiation process is wrapped as a {@link DatatypeConfigurationException}.
+ * </li>
+ * </ol>
+ *
+ * @author <a href="mailto:Joseph.Fialli@Sun.COM">Joseph Fialli</a>
+ * @author <a href="mailto:Jeff.Suttor@Sun.com">Jeff Suttor</a>
+ * @version $Id: DatatypeFactoryImpl.java 554381 2007-07-08 16:03:48Z mrglavas $
+ */
+@SuppressWarnings("all")
+public class DatatypeFactoryImpl extends DatatypeFactory {
+
+ /**
+ * <p>Public constructor is empty..</p>
+ *
+ * <p>Use {@link DatatypeFactory#newInstance()} to create a <code>DatatypeFactory</code>.</p>
+ */
+ public DatatypeFactoryImpl() {}
+
+ /**
+ * <p>Obtain a new instance of a <code>Duration</code>
+ * specifying the <code>Duration</code> as its string representation, "PnYnMnDTnHnMnS",
+ * as defined in XML Schema 1.0 section 3.2.6.1.</p>
+ *
+ * <p>XML Schema Part 2: Datatypes, 3.2.6 duration, defines <code>duration</code> as:</p>
+ * <blockquote>
+ * duration represents a duration of time.
+ * The value space of duration is a six-dimensional space where the coordinates designate the
+ * Gregorian year, month, day, hour, minute, and second components defined in Section 5.5.3.2 of [ISO 8601], respectively.
+ * These components are ordered in their significance by their order of appearance i.e. as
+ * year, month, day, hour, minute, and second.
+ * </blockquote>
+ * <p>All six values are set and availabe from the created {@link Duration}</p>
+ *
+ * <p>The XML Schema specification states that values can be of an arbitrary size.
+ * Implementations may chose not to or be incapable of supporting arbitrarily large and/or small values.
+ * An {@link UnsupportedOperationException} will be thrown with a message indicating implementation limits
+ * if implementation capacities are exceeded.</p>
+ *
+ * @param lexicalRepresentation <code>String</code> representation of a <code>Duration</code>.
+ *
+ * @return New <code>Duration</code> created from parsing the <code>lexicalRepresentation</code>.
+ *
+ * @throws IllegalArgumentException If <code>lexicalRepresentation</code> is not a valid representation of a <code>Duration</code>.
+ * @throws UnsupportedOperationException If implementation cannot support requested values.
+ * @throws NullPointerException if <code>lexicalRepresentation</code> is <code>null</code>.
+ */
+ public Duration newDuration(final String lexicalRepresentation) {
+
+ return new DurationImpl(lexicalRepresentation);
+ }
+
+ /**
+ * <p>Obtain a new instance of a <code>Duration</code>
+ * specifying the <code>Duration</code> as milliseconds.</p>
+ *
+ * <p>XML Schema Part 2: Datatypes, 3.2.6 duration, defines <code>duration</code> as:</p>
+ * <blockquote>
+ * duration represents a duration of time.
+ * The value space of duration is a six-dimensional space where the coordinates designate the
+ * Gregorian year, month, day, hour, minute, and second components defined in Section 5.5.3.2 of [ISO 8601], respectively.
+ * These components are ordered in their significance by their order of appearance i.e. as
+ * year, month, day, hour, minute, and second.
+ * </blockquote>
+ * <p>All six values are set by computing their values from the specified milliseconds
+ * and are availabe using the <code>get</code> methods of the created {@link Duration}.
+ * The values conform to and are defined by:</p>
+ * <ul>
+ * <li>ISO 8601:2000(E) Section 5.5.3.2 Alternative format</li>
+ * <li><a href="http://www.w3.org/TR/xmlschema-2/#isoformats">
+ * W3C XML Schema 1.0 Part 2, Appendix D, ISO 8601 Date and Time Formats</a>
+ * </li>
+ * <li>{@link XMLGregorianCalendar} Date/Time Datatype Field Mapping Between XML Schema 1.0 and Java Representation</li>
+ * </ul>
+ *
+ * <p>The default start instance is defined by {@link GregorianCalendar}'s use of the start of the epoch: i.e.,
+ * {@link java.util.Calendar#YEAR} = 1970,
+ * {@link java.util.Calendar#MONTH} = {@link java.util.Calendar#JANUARY},
+ * {@link java.util.Calendar#DATE} = 1, etc.
+ * This is important as there are variations in the Gregorian Calendar,
+ * e.g. leap years have different days in the month = {@link java.util.Calendar#FEBRUARY}
+ * so the result of {@link Duration#getMonths()} and {@link Duration#getDays()} can be influenced.</p>
+ *
+ * @param durationInMilliseconds Duration in milliseconds to create.
+ *
+ * @return New <code>Duration</code> representing <code>durationInMilliseconds</code>.
+ */
+ public Duration newDuration(final long durationInMilliseconds) {
+
+ return new DurationImpl(durationInMilliseconds);
+ }
+
+ /**
+ * <p>Obtain a new instance of a <code>Duration</code>
+ * specifying the <code>Duration</code> as isPositive, years, months, days, hours, minutes, seconds.</p>
+ *
+ * <p>The XML Schema specification states that values can be of an arbitrary size.
+ * Implementations may chose not to or be incapable of supporting arbitrarily large and/or small values.
+ * An {@link UnsupportedOperationException} will be thrown with a message indicating implementation limits
+ * if implementation capacities are exceeded.</p>
+ *
+ * @param isPositive Set to <code>false</code> to create a negative duration. When the length
+ * of the duration is zero, this parameter will be ignored.
+ * @param years of this <code>Duration</code>
+ * @param months of this <code>Duration</code>
+ * @param days of this <code>Duration</code>
+ * @param hours of this <code>Duration</code>
+ * @param minutes of this <code>Duration</code>
+ * @param seconds of this <code>Duration</code>
+ *
+ * @return New <code>Duration</code> created from the specified values.
+ *
+ * @throws IllegalArgumentException If values are not a valid representation of a <code>Duration</code>.
+ * @throws UnsupportedOperationException If implementation cannot support requested values.
+ * @throws NullPointerException If any values are <code>null</code>.
+ *
+ * @see #newDuration(boolean isPositive, BigInteger years, BigInteger months, BigInteger days,
+ * BigInteger hours, BigInteger minutes, BigDecimal seconds)
+ */
+ public Duration newDuration(
+ final boolean isPositive,
+ final BigInteger years,
+ final BigInteger months,
+ final BigInteger days,
+ final BigInteger hours,
+ final BigInteger minutes,
+ final BigDecimal seconds) {
+
+ return new DurationImpl(
+ isPositive,
+ years,
+ months,
+ days,
+ hours,
+ minutes,
+ seconds
+ );
+ }
+
+ /**
+ * <p>Create a new instance of an <code>XMLGregorianCalendar</code>.</p>
+ *
+ * <p>All date/time datatype fields set to {@link DatatypeConstants#FIELD_UNDEFINED} or null.</p>
+ *
+ * @return New <code>XMLGregorianCalendar</code> with all date/time datatype fields set to
+ * {@link DatatypeConstants#FIELD_UNDEFINED} or null.
+ */
+ public XMLGregorianCalendar newXMLGregorianCalendar() {
+
+ return new XMLGregorianCalendarImpl();
+ }
+
+ /**
+ * <p>Create a new XMLGregorianCalendar by parsing the String as a lexical representation.</p>
+ *
+ * <p>Parsing the lexical string representation is defined in
+ * <a href="http://www.w3.org/TR/xmlschema-2/#dateTime-order">XML Schema 1.0 Part 2, Section 3.2.[7-14].1,
+ * <em>Lexical Representation</em>.</a></p>
+ *
+ * <p>The string representation may not have any leading and trailing whitespaces.</p>
+ *
+ * <p>The parsing is done field by field so that
+ * the following holds for any lexically correct String x:</p>
+ * <pre>
+ * newXMLGregorianCalendar(x).toXMLFormat().equals(x)
+ * </pre>
+ * <p>Except for the noted lexical/canonical representation mismatches
+ * listed in <a href="http://www.w3.org/2001/05/xmlschema-errata#e2-45">
+ * XML Schema 1.0 errata, Section 3.2.7.2</a>.</p>
+ *
+ * @param lexicalRepresentation Lexical representation of one the eight XML Schema date/time datatypes.
+ *
+ * @return <code>XMLGregorianCalendar</code> created from the <code>lexicalRepresentation</code>.
+ *
+ * @throws IllegalArgumentException If the <code>lexicalRepresentation</code> is not a valid <code>XMLGregorianCalendar</code>.
+ * @throws NullPointerException If <code>lexicalRepresentation</code> is <code>null</code>.
+ */
+ public XMLGregorianCalendar newXMLGregorianCalendar(final String lexicalRepresentation) {
+
+ return new XMLGregorianCalendarImpl(lexicalRepresentation);
+ }
+
+ /**
+ * <p>Create an <code>XMLGregorianCalendar</code> from a {@link GregorianCalendar}.</p>
+ *
+ * <table border="2" rules="all" cellpadding="2">
+ * <thead>
+ * <tr>
+ * <th align="center" colspan="2">
+ * Field by Field Conversion from
+ * {@link GregorianCalendar} to an {@link XMLGregorianCalendar}
+ * </th>
+ * </tr>
+ * <tr>
+ * <th><code>java.util.GregorianCalendar</code> field</th>
+ * <th><code>javax.xml.datatype.XMLGregorianCalendar</code> field</th>
+ * </tr>
+ * </thead>
+ * <tbody>
+ * <tr>
+ * <td><code>ERA == GregorianCalendar.BC ? -YEAR : YEAR</code></td>
+ * <td>{@link XMLGregorianCalendar#setYear(int year)}</td>
+ * </tr>
+ * <tr>
+ * <td><code>MONTH + 1</code></td>
+ * <td>{@link XMLGregorianCalendar#setMonth(int month)}</td>
+ * </tr>
+ * <tr>
+ * <td><code>DAY_OF_MONTH</code></td>
+ * <td>{@link XMLGregorianCalendar#setDay(int day)}</td>
+ * </tr>
+ * <tr>
+ * <td><code>HOUR_OF_DAY, MINUTE, SECOND, MILLISECOND</code></td>
+ * <td>{@link XMLGregorianCalendar#setTime(int hour, int minute, int second, BigDecimal fractional)}</td>
+ * </tr>
+ * <tr>
+ * <td>
+ * <code>(ZONE_OFFSET + DST_OFFSET) / (60*1000)</code><br/>
+ * <em>(in minutes)</em>
+ * </td>
+ * <td>{@link XMLGregorianCalendar#setTimezone(int offset)}<sup><em>*</em></sup>
+ * </td>
+ * </tr>
+ * </tbody>
+ * </table>
+ * <p><em>*</em>conversion loss of information. It is not possible to represent
+ * a <code>java.util.GregorianCalendar</code> daylight savings timezone id in the
+ * XML Schema 1.0 date/time datatype representation.</p>
+ *
+ * <p>To compute the return value's <code>TimeZone</code> field,
+ * <ul>
+ * <li>when <code>this.getTimezone() != FIELD_UNDEFINED</code>,
+ * create a <code>java.util.TimeZone</code> with a custom timezone id
+ * using the <code>this.getTimezone()</code>.</li>
+ * <li>else use the <code>GregorianCalendar</code> default timezone value
+ * for the host is defined as specified by
+ * <code>java.util.TimeZone.getDefault()</code>.</li></p>
+ *
+ * @param cal <code>java.util.GregorianCalendar</code> used to create <code>XMLGregorianCalendar</code>
+ *
+ * @return <code>XMLGregorianCalendar</code> created from <code>java.util.GregorianCalendar</code>
+ *
+ * @throws NullPointerException If <code>cal</code> is <code>null</code>.
+ */
+ public XMLGregorianCalendar newXMLGregorianCalendar(final GregorianCalendar cal) {
+
+ return new XMLGregorianCalendarImpl(cal);
+ }
+
+ /**
+ * <p>Constructor of value spaces that a
+ * <code>java.util.GregorianCalendar</code> instance would need to convert to an
+ * <code>XMLGregorianCalendar</code> instance.</p>
+ *
+ * <p><code>XMLGregorianCalendar eon</code> and
+ * <code>fractionalSecond</code> are set to <code>null</code></p>
+ *
+ * <p>A {@link DatatypeConstants#FIELD_UNDEFINED} value indicates that field isnot set.</p>
+ *
+ * @param year of <code>XMLGregorianCalendar</code> to be created.
+ * @param month of <code>XMLGregorianCalendar</code> to be created.
+ * @param day of <code>XMLGregorianCalendar</code> to be created.
+ * @param hour of <code>XMLGregorianCalendar</code> to be created.
+ * @param minute of <code>XMLGregorianCalendar</code> to be created.
+ * @param second of <code>XMLGregorianCalendar</code> to be created.
+ * @param millisecond of <code>XMLGregorianCalendar</code> to be created.
+ * @param timezone of <code>XMLGregorianCalendar</code> to be created.
+ *
+ * @return <code>XMLGregorianCalendar</code> created from specified values.
+ *
+ * @throws IllegalArgumentException If any individual parameter's value is outside the maximum value constraint for the field
+ * as determined by the Date/Time Data Mapping table in {@link XMLGregorianCalendar}
+ * or if the composite values constitute an invalid <code>XMLGregorianCalendar</code> instance
+ * as determined by {@link XMLGregorianCalendar#isValid()}.
+ */
+ public XMLGregorianCalendar newXMLGregorianCalendar(
+ final int year,
+ final int month,
+ final int day,
+ final int hour,
+ final int minute,
+ final int second,
+ final int millisecond,
+ final int timezone) {
+ return XMLGregorianCalendarImpl.createDateTime(
+ year,
+ month,
+ day,
+ hour,
+ minute,
+ second,
+ millisecond,
+ timezone);
+ }
+
+ /**
+ * <p>Constructor allowing for complete value spaces allowed by
+ * W3C XML Schema 1.0 recommendation for xsd:dateTime and related
+ * builtin datatypes. Note that <code>year</code> parameter supports
+ * arbitrarily large numbers and fractionalSecond has infinite
+ * precision.</p>
+ *
+ * @param year of <code>XMLGregorianCalendar</code> to be created.
+ * @param month of <code>XMLGregorianCalendar</code> to be created.
+ * @param day of <code>XMLGregorianCalendar</code> to be created.
+ * @param hour of <code>XMLGregorianCalendar</code> to be created.
+ * @param minute of <code>XMLGregorianCalendar</code> to be created.
+ * @param second of <code>XMLGregorianCalendar</code> to be created.
+ * @param fractionalSecond of <code>XMLGregorianCalendar</code> to be created.
+ * @param timezone of <code>XMLGregorianCalendar</code> to be created.
+ *
+ * @return <code>XMLGregorianCalendar</code> created from specified values.
+ *
+ * @throws IllegalArgumentException If any individual parameter's value is outside the maximum value constraint for the field
+ * as determined by the Date/Time Data Mapping table in {@link XMLGregorianCalendar}
+ * or if the composite values constitute an invalid <code>XMLGregorianCalendar</code> instance
+ * as determined by {@link XMLGregorianCalendar#isValid()}.
+ * @throws NullPointerException If any parameters are <code>null</code>.
+ *
+ */
+ public XMLGregorianCalendar newXMLGregorianCalendar(
+ final BigInteger year,
+ final int month,
+ final int day,
+ final int hour,
+ final int minute,
+ final int second,
+ final BigDecimal fractionalSecond,
+ final int timezone) {
+
+ return new XMLGregorianCalendarImpl(
+ year,
+ month,
+ day,
+ hour,
+ minute,
+ second,
+ fractionalSecond,
+ timezone
+ );
+ }
+}