*

*   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.

*/

    public static final short MAJOR_VERSION_NUMBER = (short) 1; // for serialization

    public static final short MINOR_VERSION_NUMBER = (short) 1; // for serialization

    public final Object monitor()

    {

        if (has_store())

            return get_store().get_locale();

        return this;

    }

    private static XmlObjectBase underlying(XmlObject obj)

    {

        if (obj == null)

            return null;

        if (obj instanceof XmlObjectBase)

            return (XmlObjectBase)obj;

        while (obj instanceof DelegateXmlObject)

            obj = ((DelegateXmlObject)obj).underlyingXmlObject();

        if (obj instanceof XmlObjectBase)

            return (XmlObjectBase)obj;

        throw new IllegalStateException("Non-native implementations of XmlObject should extend FilterXmlObject or implement DelegateXmlObject");

    }

    public final XmlObject copy()

    {

        if (preCheck())

            return _copy();

        else

            synchronized (monitor())

            {

                return _copy();

            }

    }

    private boolean preCheck()

    {

//            return true;

        if ( has_store() )

            return get_store().get_locale().noSync();

        return false;

    }

    /**

     * Same as copy() but unsynchronized.

     * Warning: Using this method in mutithreaded environment can cause invalid states.

     */

    public final XmlObject _copy()

    {

        return _copy(null);

    }

    /**

     * Same as copy() but unsynchronized.

     * If Locale.COPY_USE_NEW_LOCALE is set in the options, a new locale will be created for the copy.

     * Warning: Using this method in mutithreaded environment can cause invalid states.

     */

    public final XmlObject _copy(XmlOptions xmlOptions)

    {

        // immutable objects don't get copied. They're immutable

        if (isImmutable())

            return this;

        check_orphaned();

        SchemaTypeLoader stl = get_store().get_schematypeloader();

        XmlObject result = (XmlObject)get_store().copy(stl, schemaType(), xmlOptions);

        return result;

    }

    public XmlDocumentProperties documentProperties()

        { XmlCursor cur = newCursorForce(); try { return cur.documentProperties(); } finally { cur.dispose(); } }

    /**

     * @deprecated XMLInputStream was deprecated by XMLStreamReader from STaX - jsr173 API.

     */

    public XMLInputStream newXMLInputStream()

        { return newXMLInputStream(null); }

    /**

     * @deprecated XMLInputStream was deprecated by XMLStreamReader from STaX - jsr173 API.

     */

    public XMLInputStream newXMLInputStream(XmlOptions options)

        { XmlCursor cur = newCursorForce(); try { return cur.newXMLInputStream(makeInnerOptions(options)); } finally { cur.dispose(); } }

    public XMLStreamReader newXMLStreamReader()

        { return newXMLStreamReader(null); }

    public XMLStreamReader newXMLStreamReader(XmlOptions options)

        { XmlCursor cur = newCursorForce(); try { return cur.newXMLStreamReader(makeInnerOptions(options)); } finally { cur.dispose(); } }

    public InputStream newInputStream()

        { return newInputStream(null); }

    public InputStream newInputStream(XmlOptions options)

        { XmlCursor cur = newCursorForce(); try { return cur.newInputStream(makeInnerOptions(options)); } finally { cur.dispose(); } }

    public Reader newReader()

        { return newReader(null); }

    public Reader newReader(XmlOptions options)

        { XmlCursor cur = newCursorForce(); try { return cur.newReader(makeInnerOptions(options)); } finally { cur.dispose(); } }

    public Node getDomNode()

        { XmlCursor cur = newCursorForce(); try { return cur.getDomNode(); } finally { cur.dispose(); } }

    public Node newDomNode()

        { return newDomNode(null); }

    public Node newDomNode(XmlOptions options)

        { XmlCursor cur = newCursorForce(); try { return cur.newDomNode(makeInnerOptions(options)); } finally { cur.dispose(); } }

    public void save(ContentHandler ch, LexicalHandler lh, XmlOptions options) throws SAXException

        { XmlCursor cur = newCursorForce(); try { cur.save(ch, lh, makeInnerOptions(options)); } finally { cur.dispose(); } }

    public void save(File file, XmlOptions options) throws IOException

        { XmlCursor cur = newCursorForce(); try { cur.save(file, makeInnerOptions(options)); } finally { cur.dispose(); } }

    public void save(OutputStream os, XmlOptions options) throws IOException

        { XmlCursor cur = newCursorForce(); try { cur.save(os, makeInnerOptions(options)); } finally { cur.dispose(); } }

    public void save(Writer w, XmlOptions options) throws IOException

        { XmlCursor cur = newCursorForce(); try { cur.save(w, makeInnerOptions(options)); } finally { cur.dispose(); } }

    public void save(ContentHandler ch, LexicalHandler lh) throws SAXException

        { save( ch, lh, null ); }

    public void save(File file) throws IOException

        { save( file, null ); }

    public void save(OutputStream os) throws IOException

        { save( os, null ); }

    public void save(Writer w) throws IOException

        { save( w, null ); }

    public void dump()

        { XmlCursor cur = newCursorForce(); try { cur.dump(); } finally { cur.dispose(); } }

    public XmlCursor newCursorForce()

    {

        synchronized (monitor())

        {

            return ensureStore().newCursor();

        }

    }

    private XmlObject ensureStore()

    {

        if ((_flags & FLAG_STORE) != 0)

            return this;

        check_dated();

        String value =

            (_flags & FLAG_NIL) != 0

                ? ""

                : compute_text( has_store() ? get_store() : null );

        XmlOptions options = new XmlOptions().setDocumentType(schemaType());

        XmlObject x = XmlObject.Factory.newInstance( options );

        XmlCursor c = x.newCursor();

        c.toNextToken();

        c.insertChars( value );

        return x;

    }

    private static XmlOptions makeInnerOptions(XmlOptions options)

    {

        XmlOptions innerOptions = new XmlOptions( options );

        innerOptions.put( XmlOptions.SAVE_INNER );

        return innerOptions;

    }

    public XmlCursor newCursor()

    {

        if ((_flags & FLAG_STORE) == 0)

            throw new IllegalStateException("XML Value Objects cannot create cursors");

        check_orphaned();

        // Note that new_cursor does not really need sync ....

        XmlLocale l = getXmlLocale();

        if (l.noSync())         { l.enter(); try { return get_store().new_cursor(); } finally { l.exit(); } }

        else synchronized ( l ) { l.enter(); try { return get_store().new_cursor(); } finally { l.exit(); } }

    }

    public abstract SchemaType schemaType();

    public SchemaType instanceType()

        { synchronized (monitor()) { return isNil() ? null : schemaType(); } }

    private SchemaField schemaField() {

        SchemaType st = schemaType();

        SchemaField field;

        // First check if this field has an anonymous type

        field = st.getContainerField();

        if (field == null)

            field = get_store().get_schema_field();

        return field;

    }

    /**

     * Use _voorVc when you want to throw a ValueOutOfRangeException when

     * validating a simple type.

     */

    private static final class ValueOutOfRangeValidationContext implements ValidationContext

    {

        public void invalid(String message)

        {

            throw new XmlValueOutOfRangeException( message );

        }

        public void invalid(String code, Object[] args)

        {

            throw new XmlValueOutOfRangeException( code, args );

        }

    }

    /**

     * Used to supply validation context for the validate_value methods

     */

    private static final class ImmutableValueValidationContext implements ValidationContext

    {

        private XmlObject _loc;

        private Collection _coll;

        ImmutableValueValidationContext(Collection coll, XmlObject loc)

        {

            _coll = coll;

            _loc = loc;

        }

        public void invalid(String message)

        {

           _coll.add(XmlError.forObject(message, _loc));

        }

        public void invalid(String code, Object[] args)

        {

            _coll.add(XmlError.forObject(code, args, _loc));

        }

    }

    public static final ValidationContext _voorVc = new ValueOutOfRangeValidationContext();

    public boolean validate()

        { return validate(null); }

    public boolean validate(XmlOptions options)

    {

        if ((_flags & FLAG_STORE) == 0)

        {

            if ((_flags & FLAG_IMMUTABLE) != 0)

            {

                return validate_immutable(options);

            }

            throw new IllegalStateException(

                    "XML objects with no underlying store cannot be validated");

        }

        synchronized (monitor())

        {

            if ((_flags & FLAG_ORPHANED) != 0)

                throw new XmlValueDisconnectedException();

            SchemaField field = schemaField();

            SchemaType type = schemaType();

            TypeStore typeStore = get_store();

            Validator validator =

                new Validator(

                    type, field, typeStore.get_schematypeloader(), options, null);

            typeStore.validate( validator );

            return validator.isValid();

        }

    }

    private boolean validate_immutable(XmlOptions options)

    {

        Collection errorListener = options == null ? null : (Collection)options.get(XmlOptions.ERROR_LISTENER);

        XmlErrorWatcher watcher = new XmlErrorWatcher(errorListener);

        if (!(schemaType().isSimpleType() || options != null &&

                options.hasOption(XmlOptions.VALIDATE_TEXT_ONLY)))

        {

            // cannot have any required attributes or elements

            SchemaProperty[] properties = schemaType().getProperties();

            for (int i = 0; i < properties.length; i++)

            {

                if (properties[i].getMinOccurs().signum() > 0)

                {

                    // KHK: error code?

                    if (properties[i].isAttribute())

                        watcher.add(XmlError.forObject(XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$MISSING_REQUIRED_ATTRIBUTE, new Object[]{QNameHelper.pretty(properties[i].getName()), }, this));

                    else

                        watcher.add(XmlError.forObject(XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$MISSING_ELEMENT, new Object[]{properties[i].getMinOccurs(), QNameHelper.pretty(properties[i].getName()), }, this));

                }

            }

            if (schemaType().getContentType() != SchemaType.SIMPLE_CONTENT)

                return !watcher.hasError(); // don't validate non-simple-content

        }

        String text = (String)_textsource;

        if (text == null)

            text = "";

        validate_simpleval(text, new ImmutableValueValidationContext(watcher, this));

        return !watcher.hasError();

    }

    protected void validate_simpleval(String lexical, ValidationContext ctx)

    {

        return;

    }

    private static XmlObject[] _typedArray(XmlObject[] input)

    {

        if (input.length == 0)

            return input;

        SchemaType commonType = input[0].schemaType();

        if (commonType.equals(XmlObject.type) || commonType.isNoType())

            return input;

        for (int i = 1; i < input.length; i++)

        {

            if (input[i].schemaType().isNoType())

                return input;

            commonType = commonType.getCommonBaseType(input[i].schemaType());

            if (commonType.equals(XmlObject.type))

                return input;

        }

        Class desiredClass = commonType.getJavaClass();

        while (desiredClass == null)

        {

            commonType = commonType.getBaseType();

            if (XmlObject.type.equals(commonType))

                return input;

            desiredClass = commonType.getJavaClass();

        }

        XmlObject[] result = (XmlObject[])Array.newInstance(desiredClass, input.length);