All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.apache.xmlbeans.XmlBeans Maven / Gradle / Ivy

There is a newer version: 5.0.70
Show newest version
/*   Copyright 2004 The Apache Software Foundation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package org.apache.xmlbeans;

import javax.xml.namespace.QName;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Constructor;
import java.lang.ref.SoftReference;
import java.io.File;

import javax.xml.stream.XMLStreamReader;

import org.w3c.dom.Node;

/**
 * Provides an assortment of utilities
 * for managing XML Bean types, type systems, QNames, paths,
 * and queries.
 */
public final class XmlBeans
{
    private static String XMLBEANS_TITLE = "org.apache.xmlbeans";
    private static String XMLBEANS_VERSION = "3.1.0";
    private static String XMLBEANS_VENDOR = "Apache Software Foundation";

    static
    {
        Package pkg = XmlBeans.class.getPackage();
        if (pkg != null && pkg.getImplementationVersion() != null) {
            XMLBEANS_TITLE = pkg.getImplementationTitle();
            XMLBEANS_VERSION = pkg.getImplementationVersion();
            XMLBEANS_VENDOR = pkg.getImplementationVendor();
        }
    }

    /**
     * Returns the XmlBeans Package title, "org.apache.xmlbeans",
     * the value of
     * {@link Package#getImplementationTitle() XmlBeans.class.getPackage().getImplementationTitle()}.
     */
    public static final String getTitle()
    {
        return XMLBEANS_TITLE;
    }

    /**
     * Returns the XmlBeans vendor, "Apache Software Foundation",
     * the value of
     * {@link Package#getImplementationVendor() XmlBeans.class.getPackage().getImplementationVendor()}.
     */
    public static final String getVendor()
    {
        return XMLBEANS_VENDOR;
    }

    /**
     * Returns the XmlBeans version,
     * the value of
     * {@link Package#getImplementationVersion() XmlBeans.class.getPackage().getImplementationVersion()}.
     */
    public static final String getVersion()
    {
        return XMLBEANS_VERSION;
    }

    /**
     * Thread local QName cache for general use
     */
    private static final ThreadLocal _threadLocalLoaderQNameCache =
        new ThreadLocal()
        {
            protected Object initialValue()
            {
                return new SoftReference(new QNameCache( 32 ));
            }
        };

    public static void clearThreadLocals() {
        // clear thread local here
        _threadLocalLoaderQNameCache.remove();
    }

    /**
     * Returns a thread local QNameCache
     */
    public static QNameCache getQNameCache ( )
    {
        SoftReference softRef = (SoftReference)_threadLocalLoaderQNameCache.get();
        QNameCache qnameCache = (QNameCache) (softRef).get();
        if (qnameCache==null)
        {
            qnameCache = new QNameCache( 32 );
            _threadLocalLoaderQNameCache.set(new SoftReference(qnameCache));
        }
        return qnameCache;
    }

    /**
     * Obtains a name from the thread local QNameCache
     */
    public static QName getQName ( String localPart )
    {
        return getQNameCache().getName( "",  localPart );
    }

    /**
     * Obtains a name from the thread local QNameCache
     */

    public static QName getQName ( String namespaceUri, String localPart )
    {
        return getQNameCache().getName( namespaceUri,  localPart );
    }

    private static final Method _getContextTypeLoaderMethod = buildGetContextTypeLoaderMethod();
    private static final Method _getBuiltinSchemaTypeSystemMethod = buildGetBuiltinSchemaTypeSystemMethod();
    private static final Method _getNoTypeMethod = buildGetNoTypeMethod();
    private static final Method _typeLoaderBuilderMethod = buildTypeLoaderBuilderMethod();
    private static final Method _compilationMethod = buildCompilationMethod();
    private static final Method _nodeToCursorMethod = buildNodeToCursorMethod();
    private static final Method _nodeToXmlObjectMethod = buildNodeToXmlObjectMethod();
    private static final Method _nodeToXmlStreamMethod = buildNodeToXmlStreamMethod();
    private static final Method _streamToNodeMethod = buildStreamToNodeMethod();
    private static final Constructor _pathResourceLoaderConstructor = buildPathResourceLoaderConstructor();

    private static RuntimeException causedException ( RuntimeException e, Throwable cause )
    {
        e.initCause( cause );

        return e;
    }

    private static XmlException wrappedException(Throwable e)
    {
        if (e instanceof XmlException)
            return (XmlException) e;

        return new XmlException( e.getMessage(), e );
    }

    private static final Constructor buildConstructor ( String className, Class[] args )
    {
        try
        {
            return
                Class.forName(
                    className, false, XmlBeans.class.getClassLoader() ).
                getConstructor( args );
        }
        catch ( Exception e )
        {
            throw causedException(
                new IllegalStateException(
                    "Cannot load constructor for " + className +
                ": verify that xbean.jar is on the classpath" ), e );
        }
    }

    private static final Method buildMethod ( String className, String methodName, Class[] args )
    {
        try
        {
            return
                Class.forName(
                    className, false, XmlBeans.class.getClassLoader() ).
                        getMethod( methodName, args );
        }
        catch ( Exception e )
        {
            throw causedException(
                new IllegalStateException(
                    "Cannot load " + methodName +
                        ": verify that xbean.jar is on the classpath" ), e );
        }
    }

    private static final Method buildNoArgMethod ( String className, String methodName )
    {
        return buildMethod( className, methodName, new Class[ 0 ] );
    }

    private static final Method buildNodeMethod ( String className, String methodName )
    {
        return buildMethod( className, methodName, new Class[] { Node.class } );
    }

    private static Method buildGetContextTypeLoaderMethod()
    {
        return buildNoArgMethod( "org.apache.xmlbeans.impl.schema.SchemaTypeLoaderImpl", "getContextTypeLoader" );
    }


    private static final Method buildGetBuiltinSchemaTypeSystemMethod()
    {
        return buildNoArgMethod( "org.apache.xmlbeans.impl.schema.BuiltinSchemaTypeSystem", "get" );
    }

    private static final Method buildGetNoTypeMethod()
    {
        return buildNoArgMethod( "org.apache.xmlbeans.impl.schema.BuiltinSchemaTypeSystem", "getNoType" );
    }

    private static final Method buildTypeLoaderBuilderMethod ( )
    {
        return
            buildMethod(
                "org.apache.xmlbeans.impl.schema.SchemaTypeLoaderImpl", "build",
                new Class[] { SchemaTypeLoader[].class, ResourceLoader.class, ClassLoader.class } );
    }

    private static final Method buildCompilationMethod()
    {
        return
            buildMethod(
                "org.apache.xmlbeans.impl.schema.SchemaTypeSystemCompiler", "compile",
                new Class[] { String.class, SchemaTypeSystem.class, XmlObject[].class, BindingConfig.class, SchemaTypeLoader.class, Filer.class, XmlOptions.class } );
    }

    private static final Method buildNodeToCursorMethod()
    {
        return buildNodeMethod( "org.apache.xmlbeans.impl.store.Locale", "nodeToCursor" );
    }

    private static final Method buildNodeToXmlObjectMethod()
    {
        return buildNodeMethod( "org.apache.xmlbeans.impl.store.Locale", "nodeToXmlObject" );
    }

    private static final Method buildNodeToXmlStreamMethod()
    {
        return buildNodeMethod( "org.apache.xmlbeans.impl.store.Locale", "nodeToXmlStream" );
    }

    private static final Method buildStreamToNodeMethod()
    {
        return
            buildMethod(
                "org.apache.xmlbeans.impl.store.Locale", "streamToNode",
                new Class[] { XMLStreamReader.class } );
    }

    private static final Constructor buildPathResourceLoaderConstructor()
    {
        return
            buildConstructor(
                "org.apache.xmlbeans.impl.schema.PathResourceLoader",
                new Class[] { File[].class } );
    }

    /**
     * Compiles an XPath, returning a String equal to that which was passed,
     * but whose identity is that of one which has been precompiled and cached.
     */
    public static String compilePath ( String pathExpr ) throws XmlException
    {
        return compilePath( pathExpr, null );
    }

    /**
     * Compiles an XPath, returning a String equal to that which was passed,
     * but whose identity is that of one which has been precompiled and cached;
     * takes an option for specifying text that indicates the name of context node.
     * The default is "this", as in "$this".
     *
     * @param  options  Options for the path. For example, you can call
     * the {@link XmlOptions#setXqueryCurrentNodeVar(String) XmlOptions.setXqueryCurrentNodeVar(String)}
     * method to specify a particular name for the expression
     * variable that indicates the context node.
     */
    public static String compilePath ( String pathExpr, XmlOptions options )
        throws XmlException
    {
        return getContextTypeLoader().compilePath( pathExpr, options );
    }

    /**
     * Compiles an XQuery, returning a String equal to that which was passed,
     * but whose identity is that of one which has been precompiled and cached.
     */
    public static String compileQuery ( String queryExpr ) throws XmlException
    {
        return compileQuery( queryExpr, null );
    }

    /**
     * Compiles an XQuery, returning a String equal to that which was passed,
     * but whose identity is that of one which has been precompiled and cached;
     * takes an option for specifying text that indicates the context node.
     *
     * @param  options  Options for the query. For example, you can call
     * the {@link XmlOptions#setXqueryCurrentNodeVar(String) XmlOptions.setXqueryCurrentNodeVar(String)}
     * method to specify a particular name for the expression
     * variable that indicates the context node and the
     * {@link XmlOptions#setXqueryVariables(java.util.Map) XmlOptions.setXqueryVariables(Map)}
     * method to map external variable names to values.
     */
    public static String compileQuery ( String queryExpr, XmlOptions options )
        throws XmlException
    {
        return getContextTypeLoader().compileQuery( queryExpr, options );
    }

    /**
     * Gets the SchemaTypeLoader based on the current thread's context
     * ClassLoader. This is the SchemaTypeLoader that is used to assign
     * schema types to XML documents by default. The SchemaTypeLoader is
     * also consulted to resolve wildcards and xsi:type attributes.
     * 

* The "parse" methods of XmlBeans all delegate to the * "parseInstance" methods of the context type loader. */ public static SchemaTypeLoader getContextTypeLoader() { try { return (SchemaTypeLoader)_getContextTypeLoaderMethod.invoke(null); } catch (IllegalAccessException e) { throw causedException(new IllegalStateException("No access to SchemaTypeLoaderImpl.getContextTypeLoader(): verify that version of xbean.jar is correct"), e); } catch (InvocationTargetException e) { Throwable t = e.getCause(); IllegalStateException ise = new IllegalStateException(t.getMessage()); ise.initCause(t); // use initCause() to support Java 1.4 throw ise; } } /** * Returns the builtin type system. This SchemaTypeSystem contains * only the 46 builtin types defined by the XML Schema specification. */ public static SchemaTypeSystem getBuiltinTypeSystem() { try { return (SchemaTypeSystem)_getBuiltinSchemaTypeSystemMethod.invoke(null); } catch (IllegalAccessException e) { throw causedException(new IllegalStateException("No access to BuiltinSchemaTypeSystem.get(): verify that version of xbean.jar is correct"), e); } catch (InvocationTargetException e) { Throwable t = e.getCause(); IllegalStateException ise = new IllegalStateException(t.getMessage()); ise.initCause(t); // use initCause() to support Java 1.4 throw ise; } } /** * Creates an XmlCursor for a DOM node which is implemented by XmlBwans */ public static XmlCursor nodeToCursor ( Node n ) { try { return (XmlCursor) _nodeToCursorMethod.invoke( null, new Object[] { n } ); } catch ( IllegalAccessException e ) { throw causedException( new IllegalStateException( "No access to nodeToCursor verify that version of xbean.jar is correct" ), e ); } catch ( InvocationTargetException e ) { Throwable t = e.getCause(); IllegalStateException ise = new IllegalStateException(t.getMessage()); ise.initCause(t); // use initCause() to support Java 1.4 throw ise; } } /** * Creates an XmlObject for a DOM node which is implemented by XmlBwans */ public static XmlObject nodeToXmlObject ( Node n ) { try { return (XmlObject) _nodeToXmlObjectMethod.invoke( null, new Object[] { n } ); } catch ( IllegalAccessException e ) { throw causedException( new IllegalStateException( "No access to nodeToXmlObject verify that version of xbean.jar is correct" ), e ); } catch ( InvocationTargetException e ) { Throwable t = e.getCause(); IllegalStateException ise = new IllegalStateException(t.getMessage()); ise.initCause(t); // use initCause() to support Java 1.4 throw ise; } } /** * Creates an XmlObject for a DOM node which is implemented by XmlBwans */ public static XMLStreamReader nodeToXmlStreamReader ( Node n ) { try { return (XMLStreamReader) _nodeToXmlStreamMethod.invoke( null, new Object[] { n } ); } catch ( IllegalAccessException e ) { throw causedException( new IllegalStateException( "No access to nodeToXmlStreamReader verify that version of xbean.jar is correct" ), e ); } catch ( InvocationTargetException e ) { Throwable t = e.getCause(); IllegalStateException ise = new IllegalStateException(t.getMessage()); ise.initCause(t); // use initCause() to support Java 1.4 throw ise; } } /** * Returns the XmlObject for a DOM node which is implemented by XmlBwans */ public static Node streamToNode ( XMLStreamReader xs ) { try { return (Node) _streamToNodeMethod.invoke( null, new Object[] { xs } ); } catch ( IllegalAccessException e ) { throw causedException( new IllegalStateException( "No access to streamToNode verify that version of xbean.jar is correct" ), e ); } catch ( InvocationTargetException e ) { Throwable t = e.getCause(); IllegalStateException ise = new IllegalStateException(t.getMessage()); ise.initCause(t); // use initCause() to support Java 1.4 throw ise; } } /** * Returns the SchemaTypeSystem that results from compiling the XML * schema definitions passed. *

* Just like compileXsd, but uses the context type loader for * linking, and returns a unioned typeloader that is suitable for * creating instances. */ public static SchemaTypeLoader loadXsd(XmlObject[] schemas) throws XmlException { return loadXsd(schemas, null); } /** *

Returns the SchemaTypeSystem that results from compiling the XML * schema definitions passed in schemas.

* *

This is just like compileXsd, but uses the context type loader for * linking, and returns a unioned typeloader that is suitable for * creating instances.

* *

Use the options parameter to specify one or both of the following:

* *
    *
  • A collection instance that should be used as an error listener during * compilation, as described in {@link XmlOptions#setErrorListener}.
  • *
  • Whether validation should not be done when building the SchemaTypeSystem, * as described in {@link XmlOptions#setCompileNoValidation}.
  • *
* * @param schemas The schema definitions from which to build the schema type system. * @param options Options specifying an error listener and/or validation behavior. */ public static SchemaTypeLoader loadXsd(XmlObject[] schemas, XmlOptions options) throws XmlException { try { SchemaTypeSystem sts = (SchemaTypeSystem) _compilationMethod.invoke( null, new Object[] { null, null, schemas, null, getContextTypeLoader(), null, options }); if (sts == null) return null; return typeLoaderUnion( new SchemaTypeLoader[] { sts, getContextTypeLoader() } ); } catch (IllegalAccessException e) { throw causedException(new IllegalStateException("No access to SchemaTypeLoaderImpl.forSchemaXml(): verify that version of xbean.jar is correct"), e); } catch (InvocationTargetException e) { throw wrappedException(e.getCause()); } } /** *

Returns the SchemaTypeSystem that results from compiling the XML * schema definitions passed.

* *

The XmlObjects passed in should be w3c <schema> elements whose type * is org.w3c.x2001.xmlSchema.Schema. (That is, schema elements in * the XML namespace http://www.w3c.org/2001/XMLSchema.) Also * org.w3c.x2001.xmlSchema.SchemaDocument is permitted.

* *

The optional second argument is a SchemaTypeLoader which will be * consulted for already-compiled schema types which may be linked * while processing the given schemas.

* *

The SchemaTypeSystem that is returned should be combined * (via {@link #typeLoaderUnion}) with the typepath typeloader in order * to create a typeloader that can be used for creating and validating * instances.

* *

Use the options parameter to specify the following:

* *
    *
  • A collection instance that should be used as an error listener during * compilation, as described in {@link XmlOptions#setErrorListener}.
  • *
  • Whether validation should not be done when building the SchemaTypeSystem, * as described in {@link XmlOptions#setCompileNoValidation}.
  • *
* * @param schemas The schema definitions from which to build the schema type system. * @param typepath The path to already-compiled schema types for linking while processing. * @param options Options specifying an error listener and/or validation behavior. */ public static SchemaTypeSystem compileXsd(XmlObject[] schemas, SchemaTypeLoader typepath, XmlOptions options) throws XmlException { return compileXmlBeans(null, null, schemas, null, typepath, null, options); } /** *

Returns the SchemaTypeSystem that results from augumenting the * SchemaTypeSystem passed in by incrementally adding the given XML * schema definitions.

* *

These could be new definitions (if the Schema document is not recorded into * the existing SchemaTypeSystem), modifications to the already existing * definitions (if the Schema document is already recorded in the existing * SchemaTypeSystem), or deletions (if the Schema document is already recorded * in the existing SchemaTypeSystem and the new definitions are empty). * The identity of documents is established using * {@link XmlDocumentProperties#getSourceName}, so if the caller choses to * construct the Schema definitions using other methods than parsing an * XML document, they should make sure that the names returned by that * method are consistent with the caller's intent (add/modify).

* *

The XmlObjects passed in should be w3c <schema> elements whose type * is org.w3c.x2001.xmlSchema.Schema. (That is, schema elements in * the XML namespace http://www.w3c.org/2001/XMLSchema.) Also * org.w3c.x2001.xmlSchema.SchemaDocument is permitted.

* *

The optional second argument is a SchemaTypeLoader which will be * consulted for already-compiled schema types which may be linked * while processing the given schemas.

* *

The SchemaTypeSystem that is returned should be combined * (via {@link #typeLoaderUnion}) with the typepath typeloader in order * to create a typeloader that can be used for creating and validating * instances.

* *

Use the options parameter to specify the following:

* *
    *
  • A collection instance that should be used as an error listener during * compilation, as described in {@link XmlOptions#setErrorListener}.
  • *
  • Whether validation should not be done when building the SchemaTypeSystem, * as described in {@link XmlOptions#setCompileNoValidation}.
  • *
* * @param schemas The schema definitions from which to build the schema type system. * @param typepath The path to already-compiled schema types for linking while processing. * @param options Options specifying an error listener and/or validation behavior. */ public static SchemaTypeSystem compileXsd(SchemaTypeSystem system, XmlObject[] schemas, SchemaTypeLoader typepath, XmlOptions options) throws XmlException { return compileXmlBeans(null, system, schemas, null, typepath, null, options); } /** *

Returns the SchemaTypeSystem that results from augumenting the * SchemaTypeSystem passed in by incrementally adding the given XML * schema definitions.

* *

These could be new definitions (if the Schema document is not recorded into * the existing SchemaTypeSystem), modifications to the already existing * definitions (if the Schema document is already recorded in the existing * SchemaTypeSystem), or deletions (if the Schema document is already recorded * in the existing SchemaTypeSystem and the new definitions are empty). * The identity of documents is established using * {@link XmlDocumentProperties#getSourceName}, so if the caller choses to * construct the Schema definitions using other methods than parsing an * XML document, they should make sure that the names returned by that * method are consistent with the caller's intent (add/modify).

* *

The XmlObjects passed in should be w3c <schema> elements whose type * is org.w3c.x2001.xmlSchema.Schema. (That is, schema elements in * the XML namespace http://www.w3c.org/2001/XMLSchema.) Also * org.w3c.x2001.xmlSchema.SchemaDocument is permitted.

* *

The optional name argument is used to name the compiled schema type system. * A randomly generated name will be used if the name is null.

* *

The optional {@link BindingConfig} argument is used to control the shape * of the generated code. A BindingConfig isn't used if Filer * is null.

* *

The optional SchemaTypeLoader argument will be * consulted for already-compiled schema types which may be linked * while processing the given schemas. If not specified, the context * typeloader (as returned by {@link #getContextTypeLoader}) will be used.

* *

The optional {@link Filer} argument is used to create new binary or source * files which are the product of the compilation. If the Filer is null, the * schema binaries (.xsb) files and source files won't be generated.

* *

The SchemaTypeSystem that is returned should be combined * (via {@link #typeLoaderUnion}) with the typepath typeloader in order * to create a typeloader that can be used for creating and validating * instances.

* *

Use the options parameter to specify the following:

* *
    *
  • A collection instance that should be used as an error listener during * compilation, as described in {@link XmlOptions#setErrorListener}.
  • *
  • Whether validation should not be done when building the SchemaTypeSystem, * as described in {@link XmlOptions#setCompileNoValidation}.
  • *
* * @param name The type system name or null to use a randomly generated name. * @param system A pre-existing SchemaTypeSystem used in incremental compilation. * @param schemas The schema definitions from which to build the schema type system. * @param config The configuration controls the code generation shape. * @param typepath The path to already-compiled schema types for linking while processing. * @param filer The Filer instance used to create binary binding files and source text files. * @param options Options specifying an error listener and/or validation behavior. */ public static SchemaTypeSystem compileXmlBeans(String name, SchemaTypeSystem system, XmlObject[] schemas, BindingConfig config, SchemaTypeLoader typepath, Filer filer, XmlOptions options) throws XmlException { try { return (SchemaTypeSystem)_compilationMethod.invoke(null, new Object[] { name, system, schemas, config, typepath != null ? typepath : getContextTypeLoader(), filer, options }); } catch (IllegalAccessException e) { throw new IllegalStateException("No access to SchemaTypeLoaderImpl.forSchemaXml(): verify that version of xbean.jar is correct"); } catch (InvocationTargetException e) { throw wrappedException(e.getCause()); } } /** * Returns the union of a list of typeLoaders. The returned * SchemaTypeLoader searches the given list of SchemaTypeLoaders * in order from first to last. */ public static SchemaTypeLoader typeLoaderUnion(SchemaTypeLoader[] typeLoaders) { try { if (typeLoaders.length == 1) return typeLoaders[0]; return (SchemaTypeLoader)_typeLoaderBuilderMethod.invoke(null, new Object[] {typeLoaders, null, null}); } catch (IllegalAccessException e) { throw causedException(new IllegalStateException("No access to SchemaTypeLoaderImpl: verify that version of xbean.jar is correct"), e); } catch (InvocationTargetException e) { Throwable t = e.getCause(); IllegalStateException ise = new IllegalStateException(t.getMessage()); ise.initCause(t); // use initCause() to support Java 1.4 throw ise; } } /** * Returns a SchemaTypeLoader that searches for compiled schema types * in the given ClassLoader. */ public static SchemaTypeLoader typeLoaderForClassLoader(ClassLoader loader) { try { return (SchemaTypeLoader)_typeLoaderBuilderMethod.invoke(null, new Object[] {null, null, loader}); } catch (IllegalAccessException e) { throw causedException(new IllegalStateException("No access to SchemaTypeLoaderImpl: verify that version of xbean.jar is correct"), e); } catch (InvocationTargetException e) { Throwable t = e.getCause(); IllegalStateException ise = new IllegalStateException(t.getMessage()); ise.initCause(t); // use initCause() to support Java 1.4 throw ise; } } /** * Returns a SchemaTypeLoader that searches for compiled schema types * in the given ResourceLoader. * * @see XmlBeans#resourceLoaderForPath(File[]) */ public static SchemaTypeLoader typeLoaderForResource(ResourceLoader resourceLoader) { try { return (SchemaTypeLoader)_typeLoaderBuilderMethod.invoke(null, new Object[] {null, resourceLoader, null}); } catch (IllegalAccessException e) { throw causedException(new IllegalStateException("No access to SchemaTypeLoaderImpl: verify that version of xbean.jar is correct"), e); } catch (InvocationTargetException e) { Throwable t = e.getCause(); IllegalStateException ise = new IllegalStateException(t.getMessage()); ise.initCause(t); // use initCause() to support Java 1.4 throw ise; } } private static final String HOLDER_CLASS_NAME = "TypeSystemHolder"; private static final String TYPE_SYSTEM_FIELD = "typeSystem"; /** * Returns the SchemaTypeSystem of the given name (as returned by * {@link SchemaTypeSystem#getName}) for the given ClassLoader. *

* Note: you will almost always need typeLoaderForClassLoader() * instead (see {@link XmlBeans#typeLoaderForClassLoader}). */ public static SchemaTypeSystem typeSystemForClassLoader(ClassLoader loader, String stsName) { try { ClassLoader cl = loader == null ? Thread.currentThread().getContextClassLoader() : loader; Class clazz = cl.loadClass(stsName + "." + HOLDER_CLASS_NAME); SchemaTypeSystem sts = (SchemaTypeSystem) (clazz.getDeclaredField(TYPE_SYSTEM_FIELD).get(null)); if (sts == null) { throw new RuntimeException("SchemaTypeSystem is null for field " + TYPE_SYSTEM_FIELD + " on class with name " + stsName + "." + HOLDER_CLASS_NAME + ". Please verify the version of xbean.jar is correct."); } return sts; } catch (ClassNotFoundException e) { throw causedException(new RuntimeException("Cannot load SchemaTypeSystem. " + "Unable to load class with name " + stsName + "." + HOLDER_CLASS_NAME + ". Make sure the generated binary files are on the classpath."), e); } catch (NoSuchFieldException e) { throw causedException(new RuntimeException("Cannot find field " + TYPE_SYSTEM_FIELD + " on class " + stsName + "." + HOLDER_CLASS_NAME + ". Please verify the version of xbean.jar is correct."), e); } catch (IllegalAccessException e) { throw causedException(new RuntimeException("Field " + TYPE_SYSTEM_FIELD + " on class " + stsName + "." + HOLDER_CLASS_NAME + "is not accessible. Please verify the version of xbean.jar is correct."), e); } } /** * Returns a new ResourceLoader for a search path where each component of * the path is either a directory or a compiled xbean jar. */ public static ResourceLoader resourceLoaderForPath(File[] path) { try { return (ResourceLoader)_pathResourceLoaderConstructor.newInstance(new Object[] {path}); } catch (IllegalAccessException e) { throw causedException(new IllegalStateException("No access to SchemaTypeLoaderImpl: verify that version of xbean.jar is correct"), e); } catch (InstantiationException e) { throw causedException(new IllegalStateException(e.getMessage()), e); } catch (InvocationTargetException e) { Throwable t = e.getCause(); IllegalStateException ise = new IllegalStateException(t.getMessage()); ise.initCause(t); // use initCause() to support Java 1.4 throw ise; } } /** * Returns the SchemaType from a corresponding XmlObject subclass, * or null if none. */ public static SchemaType typeForClass(Class c) { if (c == null || !XmlObject.class.isAssignableFrom(c)) return null; try { Field typeField = c.getField("type"); if (typeField == null) return null; return (SchemaType)typeField.get(null); } catch (Exception e) { return null; } } private static SchemaType getNoType() { try { return (SchemaType)_getNoTypeMethod.invoke(null); } catch (IllegalAccessException e) { throw causedException(new IllegalStateException("No access to SchemaTypeLoaderImpl.getContextTypeLoader(): verify that version of xbean.jar is correct"), e); } catch (InvocationTargetException e) { Throwable t = e.getCause(); IllegalStateException ise = new IllegalStateException(t.getMessage()); ise.initCause(t); // use initCause() to support Java 1.4 throw ise; } } /** * The SchemaType object given to an XmlObject instance when * no type can be determined. *

* The NO_TYPE is the universal derived type. That is, it is * derived from all other schema types, and no instances of the * NO_TYPE are valid. (It is not to be confused with the anyType, * which is the universal base type from which all other types * can be derived, and of which all instances are valid.) */ public static SchemaType NO_TYPE = getNoType(); private XmlBeans ( ) { } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy