jena-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From a...@apache.org
Subject [11/24] jena git commit: JENA-1537: Remove dependency on Xerces. Import needed code
Date Fri, 04 May 2018 09:03:12 GMT
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
+        );
+    }
+}


Mime
View raw message