| /* 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.impl.newstore2; |
| |
| import org.w3c.dom.Attr; |
| import org.w3c.dom.CDATASection; |
| import org.w3c.dom.CharacterData; |
| import org.w3c.dom.Comment; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.DocumentFragment; |
| import org.w3c.dom.DocumentType; |
| import org.w3c.dom.DOMException; |
| import org.w3c.dom.DOMImplementation; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.EntityReference; |
| import org.w3c.dom.NamedNodeMap; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| import org.w3c.dom.ProcessingInstruction; |
| import org.w3c.dom.Text; |
| import org.w3c.dom.DOMImplementation; |
| |
| // DOM Level 3 |
| import org.w3c.dom.UserDataHandler; |
| |
| import javax.xml.soap.Detail; |
| import javax.xml.soap.DetailEntry; |
| import javax.xml.soap.MimeHeaders; |
| import javax.xml.soap.Name; |
| import javax.xml.soap.SOAPBody; |
| import javax.xml.soap.SOAPBodyElement; |
| import javax.xml.soap.SOAPElement; |
| import javax.xml.soap.SOAPEnvelope; |
| import javax.xml.soap.SOAPException; |
| import javax.xml.soap.SOAPFactory; |
| import javax.xml.soap.SOAPFault; |
| import javax.xml.soap.SOAPHeader; |
| import javax.xml.soap.SOAPHeaderElement; |
| import javax.xml.soap.SOAPPart; |
| |
| import org.apache.xmlbeans.impl.common.XMLChar; |
| |
| import javax.xml.stream.XMLStreamReader; |
| |
| import java.io.PrintStream; |
| |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| |
| import javax.xml.transform.Source; |
| import javax.xml.namespace.QName; |
| |
| import org.apache.xmlbeans.XmlCursor; |
| |
| final class DomImpl |
| { |
| static final int ELEMENT = Node.ELEMENT_NODE; |
| static final int ATTR = Node.ATTRIBUTE_NODE; |
| static final int TEXT = Node.TEXT_NODE; |
| static final int CDATA = Node.CDATA_SECTION_NODE; |
| static final int ENTITYREF = Node.ENTITY_REFERENCE_NODE; |
| static final int ENTITY = Node.ENTITY_NODE; |
| static final int PROCINST = Node.PROCESSING_INSTRUCTION_NODE; |
| static final int COMMENT = Node.COMMENT_NODE; |
| static final int DOCUMENT = Node.DOCUMENT_NODE; |
| static final int DOCTYPE = Node.DOCUMENT_TYPE_NODE; |
| static final int DOCFRAG = Node.DOCUMENT_FRAGMENT_NODE; |
| static final int NOTATION = Node.NOTATION_NODE; |
| |
| interface Dom |
| { |
| Locale locale ( ); |
| int nodeType ( ); |
| Cur tempCur ( ); |
| QName getQName ( ); |
| |
| void dump ( ); |
| void dump ( PrintStream o ); |
| void dump ( PrintStream o, Object ref ); |
| }; |
| |
| static Dom parent ( Dom d ) { return node_getParentNode ( d ); } |
| static Dom firstChild ( Dom d ) { return node_getFirstChild ( d ); } |
| static Dom nextSibling ( Dom d ) { return node_getNextSibling( d ); } |
| |
| public static Dom append ( Dom n, Dom p ) |
| { |
| return node_insertBefore( p, n, null ); |
| } |
| |
| public static Dom insert ( Dom n, Dom b ) |
| { |
| assert b != null; |
| return node_insertBefore( parent( b ), n, b ); |
| } |
| |
| public static Dom remove ( Dom n ) |
| { |
| Dom p = parent( n ); |
| |
| if (p != null) |
| node_removeChild( p, n ); |
| |
| return n; |
| } |
| |
| // |
| // Handy dandy Dom exceptions |
| // |
| |
| static class HierarchyRequestErr extends DOMException |
| { |
| HierarchyRequestErr ( ) { this( "This node isn't allowed there" ); } |
| HierarchyRequestErr ( String message ) { super( HIERARCHY_REQUEST_ERR, message ); } |
| } |
| |
| static class WrongDocumentErr extends DOMException |
| { |
| WrongDocumentErr ( ) { this( "Nodes do not belong to the same document" ); } |
| WrongDocumentErr ( String message ) { super( WRONG_DOCUMENT_ERR, message ); } |
| } |
| |
| static class NotFoundErr extends DOMException |
| { |
| NotFoundErr ( ) { this( "Node not found" ); } |
| NotFoundErr ( String message ) { super( NOT_FOUND_ERR, message ); } |
| } |
| |
| static class NamespaceErr extends DOMException |
| { |
| NamespaceErr ( ) { this( "Namespace error" ); } |
| NamespaceErr ( String message ) { super( NAMESPACE_ERR, message ); } |
| } |
| |
| static class NoModificationAllowedErr extends DOMException |
| { |
| NoModificationAllowedErr ( ) { this( "No modification allowed error" ); } |
| NoModificationAllowedErr ( String message ) { super( NO_MODIFICATION_ALLOWED_ERR, message ); } |
| } |
| |
| static class InuseAttributeError extends DOMException |
| { |
| InuseAttributeError ( ) { this( "Attribute currently in use error" ); } |
| InuseAttributeError ( String message ) { super( INUSE_ATTRIBUTE_ERR, message ); } |
| } |
| |
| static class IndexSizeError extends DOMException |
| { |
| IndexSizeError ( ) { this( "Index Size Error" ); } |
| IndexSizeError ( String message ) { super( INDEX_SIZE_ERR, message ); } |
| } |
| |
| static class NotSupportedError extends DOMException |
| { |
| NotSupportedError ( ) { this( "This operation is not supported" ); } |
| NotSupportedError ( String message ) { super( NOT_SUPPORTED_ERR, message ); } |
| } |
| |
| static class InvalidCharacterError extends DOMException |
| { |
| InvalidCharacterError ( ) { this( "The name contains an invalid character" ); } |
| InvalidCharacterError ( String message ) { super( INVALID_CHARACTER_ERR, message ); } |
| } |
| |
| // |
| // Helper fcns |
| // |
| |
| private static final class EmptyNodeList implements NodeList |
| { |
| public int getLength ( ) { return 0; } |
| public Node item ( int i ) { return null; } |
| } |
| |
| public static NodeList _emptyNodeList = new EmptyNodeList(); |
| |
| static String nodeKindName ( int t ) |
| { |
| switch ( t ) |
| { |
| case ATTR : return "attribute"; |
| case CDATA : return "cdata section"; |
| case COMMENT : return "comment"; |
| case DOCFRAG : return "document fragment"; |
| case DOCUMENT : return "document"; |
| case DOCTYPE : return "document type"; |
| case ELEMENT : return "element"; |
| case ENTITY : return "entity"; |
| case ENTITYREF : return "entity reference"; |
| case NOTATION : return "notation"; |
| case PROCINST : return "processing instruction"; |
| case TEXT : return "text"; |
| |
| default : throw new RuntimeException( "Unknown node type" ); |
| } |
| } |
| |
| private static String isValidChild ( Dom parent, Dom child ) |
| { |
| int pk = parent.nodeType(); |
| int ck = child.nodeType(); |
| |
| switch ( pk ) |
| { |
| case DOCUMENT : |
| { |
| switch ( ck ) |
| { |
| case ELEMENT : |
| { |
| if (document_getDocumentElement( parent ) != null) |
| return "Documents may only have a maximum of one document element"; |
| |
| return null; |
| } |
| case DOCTYPE : |
| { |
| if (document_getDoctype( parent ) != null) |
| return "Documents may only have a maximum of one document type node"; |
| |
| return null; |
| } |
| case PROCINST : |
| case COMMENT : |
| return null; |
| } |
| |
| break; |
| } |
| |
| case ATTR : |
| { |
| if (ck == TEXT || ck == ENTITYREF) |
| return null; |
| |
| // TODO -- traverse the entity tree, making sure that there are |
| // only entity refs and text nodes in it. |
| |
| break; |
| } |
| |
| case DOCFRAG : |
| case ELEMENT : |
| case ENTITY : |
| case ENTITYREF : |
| { |
| switch ( ck ) |
| { |
| case ELEMENT : |
| case ENTITYREF: |
| case CDATA : |
| case TEXT : |
| case COMMENT : |
| case PROCINST : |
| return null; |
| } |
| |
| break; |
| } |
| |
| case CDATA : |
| case TEXT : |
| case COMMENT : |
| case PROCINST : |
| case DOCTYPE : |
| case NOTATION : |
| return nodeKindName( pk ) + " nodes may not have any children"; |
| } |
| |
| return |
| nodeKindName( pk ) + " nodes may not have " + |
| nodeKindName( ck ) + " nodes as children"; |
| } |
| |
| private static void validateNewChild ( Dom parent, Dom child ) |
| { |
| String msg = isValidChild( parent, child ); |
| |
| if (msg != null) |
| throw new HierarchyRequestErr( msg ); |
| |
| if (parent == child) |
| throw new HierarchyRequestErr( "New child and parent are the same node" ); |
| |
| while ( (child = parent( child )) != null ) |
| { |
| // TODO - use read only state on a node to know if it is under an |
| // entity ref |
| |
| if (child.nodeType() == ENTITYREF) |
| throw new NoModificationAllowedErr( "Entity reference trees may not be modified" ); |
| |
| if (child == parent) |
| throw new HierarchyRequestErr( "New child is an ancestor node of the parent node" ); |
| } |
| } |
| |
| private static String validatePrefix ( |
| String prefix, String uri, String local, boolean isAttr ) |
| { |
| validateNcName( prefix ); |
| |
| if (prefix == null) |
| prefix = ""; |
| |
| if (uri == null) |
| uri = ""; |
| |
| if (prefix.length() > 0 && uri.length() == 0) |
| throw new NamespaceErr( "Attempt to give a prefix for no namespace" ); |
| |
| if (prefix.equals( "xml" ) && !uri.equals( Locale._xml1998Uri )) |
| throw new NamespaceErr( "Invalid prefix - begins with 'xml'" ); |
| |
| if (isAttr) |
| { |
| if (prefix.length() > 0) |
| { |
| if (local.equals( "xmlns" )) |
| throw new NamespaceErr( "Invalid namespace - attr is default namespace already" ); |
| |
| if (Locale.beginsWithXml( local )) |
| throw new NamespaceErr( "Invalid namespace - attr prefix begins with 'xml'" ); |
| |
| if (prefix.equals( "xmlns" ) && !uri.equals( Locale._xmlnsUri )) |
| throw new NamespaceErr( "Invalid namespace - uri is not '" + Locale._xmlnsUri+";" ); |
| } |
| else |
| { |
| if (local.equals( "xmlns" ) && !uri.equals( Locale._xmlnsUri )) |
| throw new NamespaceErr( "Invalid namespace - uri is not '" + Locale._xmlnsUri+";" ); |
| } |
| } |
| else if (Locale.beginsWithXml( prefix )) |
| throw new NamespaceErr( "Invalid prefix - begins with 'xml'" ); |
| |
| return prefix; |
| } |
| |
| private static void validateName ( String name ) |
| { |
| if (name == null) |
| throw new IllegalArgumentException( "Target is null" ); |
| |
| if (name.length() == 0) |
| throw new IllegalArgumentException( "Target is empty" ); |
| |
| if (!XMLChar.isValidName( name )) |
| throw new InvalidCharacterError( "Target has an invalid character" ); |
| } |
| |
| private static void validateNcName ( String name ) |
| { |
| if (name != null && name.length() > 0 && !XMLChar.isValidNCName( name )) |
| throw new InvalidCharacterError(); |
| } |
| |
| private static void validateQualifiedName ( String name ) |
| { |
| assert name != null; |
| |
| int i = name.indexOf( ':' ); |
| |
| if (i < 0) |
| validateNcName( name ); |
| else |
| { |
| validateNcName( name.substring( 0, i ) ); |
| |
| String local = name.substring( i + 1 ); |
| |
| if (local.indexOf( ':' ) >= 0) |
| throw new NamespaceErr( "Invalid qualified name, more than one colon" ); |
| |
| validateNcName( local ); |
| } |
| } |
| |
| private static void removeNode ( Dom n ) |
| { |
| assert n.nodeType() != TEXT && n.nodeType() != CDATA; |
| |
| Cur cTo = n.tempCur(); |
| Cur cFrom = n.tempCur(); |
| |
| cFrom.toEnd(); |
| |
| if (cFrom.next()) |
| { |
| CharNode fromNodes = cFrom.getCharNodes(); |
| |
| if (fromNodes != null) |
| { |
| cFrom.setCharNodes( null ); |
| cTo.setCharNodes( CharNode.appendNodes( cTo.getCharNodes(), fromNodes ) ); |
| } |
| } |
| |
| cTo.moveNode( null ); |
| |
| cTo.release(); |
| cFrom.release(); |
| } |
| |
| private abstract static class ElementsNodeList implements NodeList |
| { |
| ElementsNodeList ( Dom root ) |
| { |
| assert root.nodeType() == DOCUMENT || root.nodeType() == ELEMENT; |
| |
| _root = root; |
| _locale = _root.locale(); |
| _version = 0; |
| } |
| |
| public int getLength ( ) |
| { |
| ensureElements(); |
| |
| return _elements.size(); |
| } |
| |
| public Node item ( int i ) |
| { |
| ensureElements(); |
| |
| return i < 0 || i >= _elements.size() ? (Node) null : (Node) _elements.get( i ); |
| } |
| |
| private void ensureElements ( ) |
| { |
| if (_version == _locale.version()) |
| return; |
| |
| _version = _locale.version(); |
| |
| _elements = new ArrayList(); |
| |
| Locale l = _locale; |
| |
| if (l.noSync()) { l.enter(); try { addElements( _root ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { addElements( _root ); } finally { l.exit(); } } |
| } |
| |
| private void addElements ( Dom node ) |
| { |
| for ( Dom c = firstChild( node ) ; c != null ; c = nextSibling( c ) ) |
| { |
| if (c.nodeType() == ELEMENT) |
| { |
| if (match( c )) |
| _elements.add( c ); |
| |
| addElements( c ); |
| } |
| } |
| } |
| |
| protected abstract boolean match ( Dom element ); |
| |
| private Dom _root; |
| private Locale _locale; |
| private long _version; |
| private ArrayList _elements; |
| } |
| |
| private static class ElementsByTagNameNodeList extends ElementsNodeList |
| { |
| ElementsByTagNameNodeList ( Dom root, String name ) |
| { |
| super( root ); |
| |
| _name = name; |
| } |
| |
| protected boolean match ( Dom element ) |
| { |
| return _name.equals( "*" ) ? true : _node_getNodeName( element ).equals( _name ); |
| } |
| |
| private String _name; |
| } |
| |
| private static class ElementsByTagNameNSNodeList extends ElementsNodeList |
| { |
| ElementsByTagNameNSNodeList ( Dom root, String uri, String local ) |
| { |
| super( root ); |
| |
| _uri = uri == null ? "" : uri; |
| _local = local; |
| } |
| |
| protected boolean match ( Dom element ) |
| { |
| if (!(_uri.equals( "*" ) ? true : _node_getNamespaceURI( element ).equals( _uri ))) |
| return false; |
| |
| return _local.equals( "*" ) ? true : _node_getLocalName( element ).equals( _local ); |
| } |
| |
| private String _uri; |
| private String _local; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Document _domImplementation_createDocument ( |
| Locale l, String u, String n, DocumentType t ) |
| { |
| Document d; |
| |
| if (l.noSync()) { l.enter(); try { d = domImplementation_createDocument( l, u, n, t ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { d = domImplementation_createDocument( l, u, n, t ); } finally { l.exit(); } } |
| |
| return d; |
| } |
| |
| public static Document domImplementation_createDocument ( |
| Locale l, String namespaceURI, String qualifiedName, DocumentType doctype ) |
| { |
| validateQualifiedName( qualifiedName ); |
| |
| Cur c = l.tempCur(); |
| |
| c.createDomDocumentRoot(); |
| |
| Document doc = (Document) c.getDom(); |
| |
| c.next(); |
| |
| c.createElement( l.makeQualifiedQName( namespaceURI, qualifiedName ) ); |
| |
| if (doctype != null) |
| throw new RuntimeException( "Not impl" ); |
| |
| c.release(); |
| |
| return doc; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static boolean _domImplementation_hasFeature ( Locale l, String feature, String version ) |
| { |
| if (feature == null) |
| return false; |
| |
| if (version != null && version.length() > 0 && |
| !version.equals( "1.0" ) && !version.equals( "2.0" )) |
| { |
| return false; |
| } |
| |
| if (feature.equalsIgnoreCase( "core" )) |
| return true; |
| |
| if (feature.equalsIgnoreCase( "xml" )) |
| return true; |
| |
| return false; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Element _document_getDocumentElement ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| Dom e; |
| |
| if (l.noSync()) { l.enter(); try { e = document_getDocumentElement( d ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { e = document_getDocumentElement( d ); } finally { l.exit(); } } |
| |
| return (Element) e; |
| } |
| |
| public static Dom document_getDocumentElement ( Dom d ) |
| { |
| for ( d = firstChild( d ) ; d != null ; d = nextSibling( d ) ) |
| { |
| if (d.nodeType() == ELEMENT) |
| return d; |
| } |
| |
| return null; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static DocumentFragment _document_createDocumentFragment ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| Dom f; |
| |
| if (l.noSync()) { l.enter(); try { f = document_createDocumentFragment( d ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { f = document_createDocumentFragment( d ); } finally { l.exit(); } } |
| |
| return (DocumentFragment) f; |
| } |
| |
| public static Dom document_createDocumentFragment ( Dom d ) |
| { |
| Cur c = d.locale().tempCur(); |
| |
| c.createDomDocFragRoot(); |
| |
| Dom f = c.getDom(); |
| |
| c.release(); |
| |
| return f; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Element _document_createElement ( Dom d, String name ) |
| { |
| Locale l = d.locale(); |
| |
| Dom e; |
| |
| if (l.noSync()) { l.enter(); try { e = document_createElement( d, name ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { e = document_createElement( d, name ); } finally { l.exit(); } } |
| |
| return (Element) e; |
| } |
| |
| public static Dom document_createElement ( Dom d, String name ) |
| { |
| validateQualifiedName( name ); |
| |
| Locale l = d.locale(); |
| |
| Cur c = l.tempCur(); |
| |
| c.createElement( l.makeQualifiedQName( "", name ) ); |
| |
| Dom e = c.getDom(); |
| |
| c.release(); |
| |
| return e; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Element _document_createElementNS ( Dom d, String uri, String qname ) |
| { |
| Locale l = d.locale(); |
| |
| Dom e; |
| |
| if (l.noSync()) { l.enter(); try { e = document_createElementNS( d, uri, qname ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { e = document_createElementNS( d, uri, qname ); } finally { l.exit(); } } |
| |
| return (Element) e; |
| } |
| |
| public static Dom document_createElementNS ( Dom d, String uri, String qname ) |
| { |
| validateQualifiedName( qname ); |
| |
| Locale l = d.locale(); |
| |
| Cur c = l.tempCur(); |
| |
| c.createElement( l.makeQualifiedQName( uri, qname ) ); |
| |
| Dom e = c.getDom(); |
| |
| c.release(); |
| |
| return e; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Attr _document_createAttribute ( Dom d, String name ) |
| { |
| Locale l = d.locale(); |
| |
| Dom a; |
| |
| if (l.noSync()) { l.enter(); try { a = document_createAttribute( d, name ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { a = document_createAttribute( d, name ); } finally { l.exit(); } } |
| |
| return (Attr) a; |
| } |
| |
| public static Dom document_createAttribute ( Dom d, String name ) |
| { |
| validateQualifiedName( name ); |
| |
| Locale l = d.locale(); |
| |
| Cur c = l.tempCur(); |
| |
| c.createAttr( l.makeQualifiedQName( "", name ) ); |
| |
| Dom e = c.getDom(); |
| |
| c.release(); |
| |
| return e; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Attr _document_createAttributeNS ( Dom d, String uri, String qname ) |
| { |
| Locale l = d.locale(); |
| |
| Dom a; |
| |
| if (l.noSync()) { l.enter(); try { a = document_createAttributeNS( d, uri, qname ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { a = document_createAttributeNS( d, uri, qname ); } finally { l.exit(); } } |
| |
| return (Attr) a; |
| } |
| |
| public static Dom document_createAttributeNS ( Dom d, String uri, String qname ) |
| { |
| validateQualifiedName( qname ); |
| |
| Locale l = d.locale(); |
| |
| Cur c = l.tempCur(); |
| |
| c.createAttr( l.makeQualifiedQName( uri, qname ) ); |
| |
| Dom e = c.getDom(); |
| |
| c.release(); |
| |
| return e; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Comment _document_createComment ( Dom d, String data ) |
| { |
| Locale l = d.locale(); |
| |
| Dom c; |
| |
| if (l.noSync()) { l.enter(); try { c = document_createComment( d, data ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { c = document_createComment( d, data ); } finally { l.exit(); } } |
| |
| return (Comment) c; |
| } |
| |
| public static Dom document_createComment ( Dom d, String data ) |
| { |
| Locale l = d.locale(); |
| |
| Cur c = l.tempCur(); |
| |
| c.createComment(); |
| |
| Dom comment = c.getDom(); |
| |
| if (data != null) |
| { |
| c.next(); |
| c.insertChars( data, 0, data.length() ); |
| } |
| |
| c.release(); |
| |
| return comment; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static ProcessingInstruction _document_createProcessingInstruction ( Dom d, String target, String data ) |
| { |
| Locale l = d.locale(); |
| |
| Dom pi; |
| |
| if (l.noSync()) { l.enter(); try { pi = document_createProcessingInstruction( d, target, data ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { pi = document_createProcessingInstruction( d, target, data ); } finally { l.exit(); } } |
| |
| return (ProcessingInstruction) pi; |
| } |
| |
| public static Dom document_createProcessingInstruction ( Dom d, String target, String data ) |
| { |
| validateName( target ); |
| |
| if (Locale.beginsWithXml( target ) && target.length() == 3) |
| throw new InvalidCharacterError( "Invalid target - is 'xml'" ); |
| |
| Locale l = d.locale(); |
| |
| Cur c = l.tempCur(); |
| |
| c.createProcinst( target ); |
| |
| Dom pi = c.getDom(); |
| |
| if (data != null) |
| { |
| c.next(); |
| c.insertChars( data, 0, data.length() ); |
| } |
| |
| c.release(); |
| |
| return pi; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static CDATASection _document_createCDATASection ( Dom d, String data ) |
| { |
| return (CDATASection) document_createCDATASection( d, data ); |
| } |
| |
| public static Dom document_createCDATASection ( Dom d, String data ) |
| { |
| TextNode t = d.locale().createCdataNode(); |
| |
| if (data == null) |
| data = ""; |
| |
| t._src = data; |
| t._off = 0; |
| t._cch = data.length(); |
| |
| return t; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Text _document_createTextNode ( Dom d, String data ) |
| { |
| return (Text) document_createTextNode( d, data ); |
| } |
| |
| public static CharNode document_createTextNode ( Dom d, String data ) |
| { |
| TextNode t = d.locale().createTextNode(); |
| |
| if (data == null) |
| data = ""; |
| |
| t._src = data; |
| t._off = 0; |
| t._cch = data.length(); |
| |
| return t; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static EntityReference _document_createEntityReference ( Dom d, String name ) |
| { |
| throw new RuntimeException( "Not implemented" ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Element _document_getElementById ( Dom d, String elementId ) |
| { |
| throw new RuntimeException( "Not implemented" ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static NodeList _document_getElementsByTagName ( Dom d, String name ) |
| { |
| Locale l = d.locale(); |
| |
| NodeList nl; |
| |
| if (l.noSync()) { l.enter(); try { nl = document_getElementsByTagName( d, name ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { nl = document_getElementsByTagName( d, name ); } finally { l.exit(); } } |
| |
| return nl; |
| } |
| |
| public static NodeList document_getElementsByTagName ( Dom d, String name ) |
| { |
| return new ElementsByTagNameNodeList( d, name ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static NodeList _document_getElementsByTagNameNS ( Dom d, String uri, String local ) |
| { |
| Locale l = d.locale(); |
| |
| NodeList nl; |
| |
| if (l.noSync()) { l.enter(); try { nl = document_getElementsByTagNameNS( d, uri, local ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { nl = document_getElementsByTagNameNS( d, uri, local ); } finally { l.exit(); } } |
| |
| return nl; |
| } |
| |
| public static NodeList document_getElementsByTagNameNS ( Dom d, String uri, String local ) |
| { |
| return new ElementsByTagNameNSNodeList( d, uri, local ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static DOMImplementation _document_getImplementation ( Dom d ) |
| { |
| return (DOMImplementation) d.locale(); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Node _document_importNode ( Dom d, Node n, boolean deep ) |
| { |
| Locale l = d.locale(); |
| Dom i; |
| |
| // // TODO - need to wrap this in sync .. |
| // if (n instanceof Dom) |
| // i = node_cloneNode( (Dom) n, deep, m ); |
| // else |
| // TODO -- I'm importing my own nodes through DOM methods! -- make this faster |
| { |
| if (l.noSync()) { l.enter(); try { i = document_importNode( d, n, deep ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { i = document_importNode( d, n, deep ); } finally { l.exit(); } } |
| } |
| |
| return (Node) i; |
| } |
| |
| public static Dom document_importNode ( Dom d, Node n, boolean deep ) |
| { |
| if (n == null) |
| return null; |
| |
| Dom i; |
| |
| boolean copyChildren = false; |
| |
| switch ( n.getNodeType() ) |
| { |
| case DOCUMENT : |
| throw new NotSupportedError( "Document nodes may not be imported" ); |
| |
| case DOCTYPE : |
| throw new NotSupportedError( "Document type nodes may not be imported" ); |
| |
| case ELEMENT : |
| { |
| String local = n.getLocalName(); |
| |
| if (local == null || local.length() == 0) |
| i = document_createElement( d, n.getNodeName() ); |
| else |
| { |
| i = document_createElementNS( d, n.getNamespaceURI(), local ); |
| |
| // TODO - unify creating element and setting prefix for perf ... |
| |
| String prefix = n.getPrefix(); |
| |
| if (prefix != null && prefix.length() > 0) |
| node_setPrefix( i, prefix ); |
| } |
| |
| NamedNodeMap attrs = n.getAttributes(); |
| |
| for ( int a = 0 ; a < attrs.getLength() ; a++ ) |
| attributes_setNamedItem( i, document_importNode( d, attrs.item( a ), true ) ); |
| |
| copyChildren = deep; |
| |
| break; |
| } |
| |
| case ATTR : |
| { |
| String local = n.getLocalName(); |
| |
| if (local == null || local.length() == 0) |
| i = document_createAttribute( d, n.getNodeName() ); |
| else |
| { |
| i = document_createAttributeNS( d, n.getNamespaceURI(), local ); |
| |
| // TODO - unify creating attr and setting prefix for perf ... |
| |
| String prefix = n.getPrefix(); |
| |
| if (prefix != null && prefix.length() > 0) |
| node_setPrefix( i, prefix ); |
| } |
| |
| copyChildren = true; |
| |
| break; |
| } |
| |
| case DOCFRAG : |
| { |
| i = document_createDocumentFragment( d ); |
| |
| copyChildren = deep; |
| |
| break; |
| } |
| |
| case PROCINST : |
| { |
| i = document_createProcessingInstruction( d, n.getNodeName(), n.getNodeValue() ); |
| break; |
| } |
| |
| case COMMENT : |
| { |
| i = document_createComment( d, n.getNodeValue() ); |
| break; |
| } |
| |
| case TEXT : |
| { |
| i = document_createTextNode( d, n.getNodeValue() ); |
| break; |
| } |
| |
| case CDATA : |
| { |
| i = document_createCDATASection( d, n.getNodeValue() ); |
| break; |
| } |
| |
| case ENTITYREF : |
| case ENTITY : |
| case NOTATION : |
| throw new RuntimeException( "Not impl" ); |
| |
| default : throw new RuntimeException( "Unknown kind" ); |
| } |
| |
| if (copyChildren) |
| { |
| NodeList children = n.getChildNodes(); |
| |
| for ( int c = 0 ; c < children.getLength() ; c++ ) |
| node_insertBefore( i, document_importNode( d, children.item( c ), true ), null); |
| } |
| |
| return i; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static DocumentType _document_getDoctype ( Dom n ) |
| { |
| throw new RuntimeException( "Not implemented" ); |
| } |
| |
| public static Dom document_getDoctype ( Dom n ) |
| { |
| throw new RuntimeException( "Not implemented" ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Document _node_getOwnerDocument ( Dom n ) |
| { |
| Locale l = n.locale(); |
| |
| Dom d; |
| |
| if (l.noSync()) { l.enter(); try { d = node_getOwnerDocument( n ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { d = node_getOwnerDocument( n ); } finally { l.exit(); } } |
| |
| return (Document) d; |
| } |
| |
| public static Dom node_getOwnerDocument ( Dom n ) |
| { |
| if (n.nodeType() == DOCUMENT) |
| return null; |
| |
| Locale l = n.locale(); |
| |
| if (l._ownerDoc == null) |
| { |
| Cur c = l.tempCur(); |
| c.createDomDocumentRoot(); |
| l._ownerDoc = c.getDom(); |
| c.release(); |
| } |
| |
| return l._ownerDoc; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Node _node_getParentNode ( Dom n ) |
| { |
| Locale l = n.locale(); |
| |
| Dom p; |
| |
| if (l.noSync()) { l.enter(); try { p = node_getParentNode( n ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { p = node_getParentNode( n ); } finally { l.exit(); } } |
| |
| return (Node) p; |
| } |
| |
| public static Dom node_getParentNode ( Dom n ) |
| { |
| Cur c = null; |
| |
| switch ( n.nodeType() ) |
| { |
| case DOCUMENT : |
| case DOCFRAG : |
| case ATTR : |
| break; |
| |
| case PROCINST : |
| case COMMENT : |
| case ELEMENT : |
| { |
| if (!(c = n.tempCur()).toParentRaw()) |
| { |
| c.release(); |
| c = null; |
| } |
| |
| break; |
| } |
| |
| case TEXT : |
| case CDATA : |
| { |
| if ((c = n.tempCur()) != null) |
| c.toParent(); |
| |
| break; |
| } |
| |
| case ENTITYREF : |
| throw new RuntimeException( "Not impl" ); |
| |
| case ENTITY : |
| case DOCTYPE : |
| case NOTATION : |
| throw new RuntimeException( "Not impl" ); |
| |
| default : throw new RuntimeException( "Unknown kind" ); |
| } |
| |
| if (c == null) |
| return null; |
| |
| Dom d = c.getDom(); |
| |
| c.release(); |
| |
| return d; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Node _node_getFirstChild ( Dom n ) |
| { |
| Locale l = n.locale(); |
| |
| Dom fc; |
| |
| if (l.noSync()) { l.enter(); try { fc = node_getFirstChild( n ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { fc = node_getFirstChild( n ); } finally { l.exit(); } } |
| |
| return (Node) fc; |
| } |
| |
| public static Dom node_getFirstChild ( Dom n ) |
| { |
| Dom fc = null; |
| |
| switch ( n.nodeType() ) |
| { |
| case TEXT : |
| case CDATA : |
| case PROCINST : |
| case COMMENT : |
| break; |
| |
| case ENTITYREF : |
| throw new RuntimeException( "Not impl" ); |
| |
| case ENTITY : |
| case DOCTYPE : |
| case NOTATION : |
| throw new RuntimeException( "Not impl" ); |
| |
| case ELEMENT : |
| case DOCUMENT : |
| case DOCFRAG : |
| case ATTR : |
| { |
| Cur c = n.tempCur(); |
| |
| c.next(); |
| |
| if ((fc = c.getCharNodes()) == null) |
| { |
| c.moveToDom( n ); |
| |
| if (c.toFirstChild()) |
| fc = c.getDom(); |
| } |
| |
| c.release(); |
| |
| break; |
| } |
| } |
| |
| // TODO - handle entity refs here ... |
| |
| return fc; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Node _node_getLastChild ( Dom n ) |
| { |
| Locale l = n.locale(); |
| |
| Dom lc; |
| |
| if (l.noSync()) { l.enter(); try { lc = node_getLastChild( n ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { lc = node_getLastChild( n ); } finally { l.exit(); } } |
| |
| return (Node) lc; |
| } |
| |
| public static Dom node_getLastChild ( Dom n ) |
| { |
| switch ( n.nodeType() ) |
| { |
| case TEXT : |
| case CDATA : |
| case PROCINST : |
| case COMMENT : |
| return null; |
| |
| case ENTITYREF : |
| throw new RuntimeException( "Not impl" ); |
| |
| case ENTITY : |
| case DOCTYPE : |
| case NOTATION : |
| throw new RuntimeException( "Not impl" ); |
| |
| case ELEMENT : |
| case DOCUMENT : |
| case DOCFRAG : |
| case ATTR : |
| break; |
| } |
| |
| Dom lc = null; |
| CharNode nodes; |
| |
| Cur c = n.tempCur(); |
| |
| if (c.toLastChild()) |
| { |
| lc = c.getDom(); |
| |
| c.skip(); |
| |
| if ((nodes = c.getCharNodes()) != null) |
| lc = null; |
| } |
| else |
| { |
| c.next(); |
| nodes = c.getCharNodes(); |
| } |
| |
| if (lc == null && nodes != null) |
| { |
| while ( nodes._next != null ) |
| nodes = nodes._next; |
| |
| lc = nodes; |
| } |
| |
| c.release(); |
| |
| // TODO - handle entity refs here ... |
| |
| return lc; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Node _node_getNextSibling ( Dom n ) |
| { |
| Locale l = n.locale(); |
| |
| Dom ns; |
| |
| if (l.noSync()) { l.enter(); try { ns = node_getNextSibling( n ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { ns = node_getNextSibling( n ); } finally { l.exit(); } } |
| |
| return (Node) ns; |
| } |
| |
| public static Dom node_getNextSibling ( Dom n ) |
| { |
| Dom ns = null; |
| |
| switch ( n.nodeType() ) |
| { |
| case DOCUMENT : |
| case DOCFRAG : |
| case ATTR : |
| break; |
| |
| case TEXT : |
| case CDATA : |
| { |
| CharNode cn = (CharNode) n; |
| |
| Cur c; |
| |
| if ((c = cn.tempCur()) != null) |
| { |
| if ((ns = cn._next) == null) |
| { |
| if (c.kind() == Cur.TEXT) |
| c.next(); |
| |
| if (c.kind() > 0) |
| ns = c.getDom(); |
| } |
| |
| c.release(); |
| } |
| |
| break; |
| } |
| |
| case PROCINST : |
| case COMMENT : |
| case ELEMENT : |
| { |
| Cur c = n.tempCur(); |
| |
| c.skip(); |
| |
| if ((ns = c.getCharNodes()) == null) |
| { |
| c.moveToDom( n ); |
| |
| if (c.toNextSibling()) |
| ns = c.getDom(); |
| } |
| |
| c.release(); |
| |
| break; |
| } |
| |
| case ENTITY : |
| case NOTATION : |
| case ENTITYREF : |
| case DOCTYPE : |
| throw new RuntimeException( "Not implemented" ); |
| } |
| |
| // TODO - handle entity refs here ... |
| |
| return ns; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Node _node_getPreviousSibling ( Dom n ) |
| { |
| Locale l = n.locale(); |
| |
| Dom ps; |
| |
| if (l.noSync()) { l.enter(); try { ps = node_getPreviousSibling( n ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { ps = node_getPreviousSibling( n ); } finally { l.exit(); } } |
| |
| return (Node) ps; |
| } |
| |
| public static Dom node_getPreviousSibling ( Dom n ) |
| { |
| // TODO - horribly inefficient impl .. make this O(1) |
| |
| Dom p = parent( n ); |
| |
| if (p == null) |
| return null; |
| |
| Dom c = firstChild( p ); |
| |
| assert c != null; |
| |
| if (c == n) |
| return null; |
| |
| for ( ; ; ) |
| { |
| Dom ns = nextSibling( c ); |
| |
| if (ns == n) |
| return c; |
| |
| c = ns; |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static boolean _node_hasAttributes ( Dom n ) |
| { |
| Locale l = n.locale(); |
| |
| if (l.noSync()) { l.enter(); try { return node_hasAttributes( n ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return node_hasAttributes( n ); } finally { l.exit(); } } |
| } |
| |
| public static boolean node_hasAttributes ( Dom n ) |
| { |
| boolean hasAttrs = false; |
| |
| if (n.nodeType() == ELEMENT) |
| { |
| Cur c = n.tempCur(); |
| |
| if (c.toFirstAttr()) |
| hasAttrs = true; |
| |
| c.release(); |
| } |
| |
| return hasAttrs; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static boolean _node_isSupported ( Dom n, String feature, String version ) |
| { |
| return _domImplementation_hasFeature( n.locale(), feature, version ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static void _node_normalize ( Dom n ) |
| { |
| Locale l = n.locale(); |
| |
| if (l.noSync()) { l.enter(); try { node_normalize( n ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { node_normalize( n ); } finally { l.exit(); } } |
| } |
| |
| public static void node_normalize ( Dom n ) |
| { |
| switch ( n.nodeType() ) |
| { |
| case TEXT : |
| case CDATA : |
| case PROCINST : |
| case COMMENT : |
| return; |
| |
| case ENTITYREF : |
| throw new RuntimeException( "Not impl" ); |
| |
| case ENTITY : |
| case DOCTYPE : |
| case NOTATION : |
| throw new RuntimeException( "Not impl" ); |
| |
| case ELEMENT : |
| case DOCUMENT : |
| case DOCFRAG : |
| case ATTR : |
| break; |
| } |
| |
| Cur c = n.tempCur(); |
| |
| c.push(); |
| |
| for ( c.nextWithAttrs() ; ! c.isAtEndOfLastPush() ; c.nextWithAttrs() ) |
| { |
| CharNode cn = c.getCharNodes(); |
| |
| if (cn != null) |
| { |
| if (!c.isText()) |
| { |
| while ( cn != null ) |
| { |
| cn._src = null; |
| cn._off = 0; |
| cn._cch = 0; |
| |
| cn = CharNode.remove( cn, cn ); |
| } |
| } |
| else if (cn._next != null) |
| { |
| while ( cn._next != null ) |
| { |
| cn._next._src = null; |
| cn._next._off = 0; |
| cn._next._cch = 0; |
| |
| cn = CharNode.remove( cn, cn._next ); |
| } |
| |
| cn._cch = Integer.MAX_VALUE; |
| } |
| |
| c.setCharNodes( cn ); |
| } |
| } |
| |
| c.release(); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static boolean _node_hasChildNodes ( Dom n ) |
| { |
| // TODO - make this faster |
| return _node_getFirstChild( n ) != null; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Node _node_appendChild ( Dom p, Node newChild ) |
| { |
| return _node_insertBefore( p, newChild, null ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Node _node_replaceChild ( Dom p, Node newChild, Node oldChild ) |
| { |
| Locale l = p.locale(); |
| |
| if (newChild == null) |
| throw new IllegalArgumentException( "Child to add is null" ); |
| |
| if (oldChild == null) |
| throw new NotFoundErr( "Child to replace is null" ); |
| |
| Dom nc; |
| |
| if (!(newChild instanceof Dom) || (nc = (Dom) newChild).locale() != l) |
| throw new WrongDocumentErr( "Child to add is from another document" ); |
| |
| Dom oc = null; |
| |
| if (!(oldChild instanceof Dom) || (oc = (Dom) oldChild).locale() != l) |
| throw new WrongDocumentErr( "Child to replace is from another document" ); |
| |
| Dom d; |
| |
| if (l.noSync()) { l.enter(); try { d = node_replaceChild( p, nc, oc ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { d = node_replaceChild( p, nc, oc ); } finally { l.exit(); } } |
| |
| return (Node) d; |
| |
| } |
| |
| public static Dom node_replaceChild ( Dom p, Dom newChild, Dom oldChild ) |
| { |
| // Remove the old child firest to avoid a dom exception raised |
| // when inserting two document elements |
| |
| Dom nextNode = node_getNextSibling( oldChild ); |
| |
| node_removeChild( p, oldChild ); |
| |
| try |
| { |
| node_insertBefore( p, newChild, nextNode ); |
| } |
| catch ( DOMException e ) |
| { |
| node_insertBefore( p, oldChild, nextNode ); |
| |
| throw e; |
| } |
| |
| return oldChild; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Node _node_insertBefore ( Dom p, Node newChild, Node refChild ) |
| { |
| Locale l = p.locale(); |
| |
| if (newChild == null) |
| throw new IllegalArgumentException( "Child to add is null" ); |
| |
| Dom nc; |
| |
| if (!(newChild instanceof Dom) || (nc = (Dom) newChild).locale() != l) |
| throw new WrongDocumentErr( "Child to add is from another document" ); |
| |
| Dom rc = null; |
| |
| if (refChild != null) |
| { |
| if (!(refChild instanceof Dom) || (rc = (Dom) refChild).locale() != l) |
| throw new WrongDocumentErr( "Reference child is from another document" ); |
| } |
| |
| Dom d; |
| |
| if (l.noSync()) { l.enter(); try { d = node_insertBefore( p, nc, rc ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { d = node_insertBefore( p, nc, rc ); } finally { l.exit(); } } |
| |
| return (Node) d; |
| } |
| |
| public static Dom node_insertBefore ( Dom p, Dom nc, Dom rc ) |
| { |
| assert nc != null; |
| |
| if (rc != null && parent( rc ) != p) |
| throw new NotFoundErr( "RefChild is not a child of this node" ); |
| |
| // TODO - obey readonly status of a substree |
| |
| int nck = nc.nodeType(); |
| |
| if (nck == DOCFRAG) |
| { |
| for ( Dom c = firstChild( nc ) ; c != null ; c = nextSibling( c ) ) |
| validateNewChild( p, c ); |
| |
| for ( Dom c = firstChild( nc ) ; c != null ; ) |
| { |
| Dom n = nextSibling( c ); |
| |
| if (rc == null) |
| append( c, p ); |
| else |
| insert( c, rc ); |
| |
| c = n; |
| } |
| |
| return nc; |
| } |
| |
| // |
| // Make sure the new child is allowed here |
| // |
| |
| validateNewChild( p, nc ); |
| |
| // |
| // Orphan the child before establishing a new parent |
| // |
| |
| remove( nc ); |
| |
| int pk = p.nodeType(); |
| |
| // Only these nodes can be modifiable parents |
| assert pk == ATTR || pk == DOCFRAG || pk == DOCUMENT || pk == ELEMENT; |
| |
| switch ( nck ) |
| { |
| case ELEMENT : |
| case COMMENT : |
| case PROCINST : |
| { |
| if (rc == null) |
| { |
| Cur cTo = p.tempCur(); |
| cTo.toEnd(); |
| Cur cFrom = nc.tempCur(); |
| cFrom.moveNode( cTo ); |
| cFrom.release(); |
| cTo.release(); |
| } |
| else |
| { |
| int rck = rc.nodeType(); |
| |
| if (rck == TEXT || rck == CDATA) |
| { |
| // Quick and dirty impl.... |
| |
| ArrayList charNodes = new ArrayList(); |
| |
| while ( rc != null && (rc.nodeType() == TEXT || rc.nodeType() == CDATA ) ) |
| { |
| Dom next = nextSibling( rc ); |
| charNodes.add( remove( rc ) ); |
| rc = next; |
| } |
| |
| if (rc == null) |
| append( nc, p ); |
| else |
| insert( nc, rc ); |
| |
| rc = nextSibling( nc ); |
| |
| for ( int i = 0 ; i < charNodes.size() ; i++ ) |
| { |
| Dom n = (Dom) charNodes.get( i ); |
| |
| if (rc == null) |
| append( n, p ); |
| else |
| insert( n, rc ); |
| } |
| } |
| else if (rck == ENTITYREF) |
| { |
| throw new RuntimeException( "Not implemented" ); |
| } |
| else |
| { |
| assert rck == ELEMENT || rck == PROCINST || rck == COMMENT; |
| Cur cFrom = nc.tempCur(); |
| Cur cTo = rc.tempCur(); |
| cFrom.moveNode( cTo ); |
| cFrom.release(); |
| cTo.release(); |
| } |
| } |
| |
| break; |
| } |
| |
| case TEXT : |
| case CDATA : |
| { |
| CharNode n = (CharNode) nc; |
| |
| assert n._prev == null && n._next == null; |
| |
| CharNode refCharNode = null; |
| Cur c = p.tempCur(); |
| |
| if (rc == null) |
| c.toEnd(); |
| else |
| { |
| int rck = rc.nodeType(); |
| |
| if (rck == TEXT || rck == CDATA) |
| c.moveToCharNode( refCharNode = (CharNode) rc ); |
| else if (rck == ENTITYREF) |
| throw new RuntimeException( "Not implemented" ); |
| else |
| c.moveToDom( rc ); |
| } |
| |
| CharNode nodes = c.getCharNodes(); |
| |
| nodes = CharNode.insertNode( nodes, n, refCharNode ); |
| |
| c.insertChars( n._src, n._off, n._cch ); |
| |
| c.setCharNodes( nodes ); |
| |
| c.release(); |
| |
| break; |
| } |
| |
| case ENTITYREF : |
| { |
| throw new RuntimeException( "Not implemented" ); |
| } |
| |
| case DOCTYPE : |
| { |
| // TODO - don't actually insert this here, associate it with the |
| // doc?? Hmm .. Perhaps I should disallow insertion into the tree |
| // at all. |
| |
| throw new RuntimeException( "Not implemented" ); |
| } |
| |
| default : throw new RuntimeException( "Unexpected child node type" ); |
| } |
| |
| return nc; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Node _node_removeChild ( Dom p, Node child ) |
| { |
| Locale l = p.locale(); |
| |
| if (child == null) |
| throw new NotFoundErr( "Child to remove is null" ); |
| |
| Dom c; |
| |
| if (!(child instanceof Dom) || (c = (Dom) child).locale() != l) |
| throw new WrongDocumentErr( "Child to remove is from another document" ); |
| |
| Dom d; |
| |
| if (l.noSync()) { l.enter(); try { d = node_removeChild( p, c ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { d = node_removeChild( p, c ); } finally { l.exit(); } } |
| |
| return (Node) d; |
| } |
| |
| public static Dom node_removeChild ( Dom parent, Dom child ) |
| { |
| if (parent( child ) != parent) |
| throw new NotFoundErr( "Child to remove is not a child of given parent" ); |
| |
| switch ( child.nodeType() ) |
| { |
| case DOCUMENT : |
| case DOCFRAG : |
| case ATTR : |
| throw new IllegalStateException(); |
| |
| case ELEMENT : |
| case PROCINST : |
| case COMMENT : |
| removeNode( child ); |
| break; |
| |
| case TEXT : |
| case CDATA : |
| { |
| Cur c = child.tempCur(); |
| |
| CharNode nodes = c.getCharNodes(); |
| |
| CharNode cn = (CharNode) child; |
| |
| assert cn._src instanceof Dom; |
| |
| cn._src = c.moveChars( null, cn._cch ); |
| cn._off = c._offSrc; |
| cn._cch = c._cchSrc; |
| |
| c.setCharNodes( CharNode.remove( nodes, cn ) ); |
| |
| c.release(); |
| |
| break; |
| } |
| |
| case ENTITYREF : |
| throw new RuntimeException( "Not impl" ); |
| |
| case ENTITY : |
| case DOCTYPE : |
| case NOTATION : |
| throw new RuntimeException( "Not impl" ); |
| |
| default : throw new RuntimeException( "Unknown kind" ); |
| } |
| |
| return child; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Node _node_cloneNode ( Dom n, boolean deep ) |
| { |
| Locale l = n.locale(); |
| |
| Dom c; |
| |
| if (l.noSync()) { l.enter(); try { c = node_cloneNode( n, deep ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { c = node_cloneNode( n, deep ); } finally { l.exit(); } } |
| |
| return (Node) c; |
| } |
| |
| public static Dom node_cloneNode ( Dom n, boolean deep ) |
| { |
| Locale l = n.locale(); |
| |
| Dom clone = null; |
| |
| if (!deep) |
| { |
| Cur shallow = null; |
| |
| switch ( n.nodeType() ) |
| { |
| case DOCUMENT : |
| shallow = l.tempCur(); |
| shallow.createDomDocumentRoot(); |
| break; |
| |
| case DOCFRAG : |
| shallow = l.tempCur(); |
| shallow.createDomDocFragRoot(); |
| break; |
| |
| case ELEMENT : |
| { |
| shallow = l.tempCur(); |
| shallow.createElement( n.getQName() ); |
| |
| Element elem = (Element) shallow.getDom(); |
| NamedNodeMap attrs = ((Element) n).getAttributes(); |
| |
| for ( int i = 0 ; i < attrs.getLength() ; i++ ) |
| elem.setAttributeNodeNS( (Attr) attrs.item( i ).cloneNode( true ) ); |
| |
| break; |
| } |
| |
| case ATTR : |
| shallow = l.tempCur(); |
| shallow.createAttr( n.getQName() ); |
| break; |
| |
| case PROCINST : |
| case COMMENT : |
| case TEXT : |
| case CDATA : |
| case ENTITYREF : |
| case ENTITY : |
| case DOCTYPE : |
| case NOTATION : |
| break; |
| } |
| |
| if (shallow != null) |
| { |
| clone = shallow.getDom(); |
| shallow.release(); |
| } |
| } |
| |
| if (clone == null) |
| { |
| switch ( n.nodeType() ) |
| { |
| case DOCUMENT : |
| case DOCFRAG : |
| case ATTR : |
| case ELEMENT : |
| case PROCINST : |
| case COMMENT : |
| { |
| Cur cClone = l.tempCur(); |
| Cur cSrc = n.tempCur(); |
| cSrc.copyNode( cClone ); |
| clone = cClone.getDom(); |
| cClone.release(); |
| cSrc.release(); |
| |
| break; |
| } |
| |
| case TEXT : |
| case CDATA : |
| { |
| Cur c = n.tempCur(); |
| |
| CharNode cn = n.nodeType() == TEXT ? l.createTextNode() : l.createCdataNode(); |
| |
| cn._src = c.getChars( ((CharNode) n)._cch ); |
| cn._off = c._offSrc; |
| cn._cch = c._cchSrc; |
| |
| clone = cn; |
| |
| c.release(); |
| |
| break; |
| } |
| |
| case ENTITYREF : |
| case ENTITY : |
| case DOCTYPE : |
| case NOTATION : |
| throw new RuntimeException( "Not impl" ); |
| |
| default : throw new RuntimeException( "Unknown kind" ); |
| } |
| } |
| |
| return clone; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static String _node_getLocalName ( Dom n ) |
| { |
| QName name = n.getQName(); |
| return name == null ? "" : name.getLocalPart(); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static String _node_getNamespaceURI ( Dom n ) |
| { |
| QName name = n.getQName(); |
| // TODO - should return the correct namespace for xmlns ... |
| return name == null ? "" : name.getNamespaceURI(); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static void _node_setPrefix ( Dom n, String prefix ) |
| { |
| Locale l = n.locale(); |
| |
| if (l.noSync()) { l.enter(); try { node_setPrefix( n, prefix ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { node_setPrefix( n, prefix ); } finally { l.exit(); } } |
| } |
| |
| public static void node_setPrefix ( Dom n, String prefix ) |
| { |
| // TODO - make it possible to set the prefix of an xmlns |
| // TODO - test to make use prefix: xml maps to the predefined namespace |
| // if set???? hmmm ... perhaps I should not allow the setting of any |
| // prefixes which start with xml unless the namespace is the predefined |
| // one and the prefix is 'xml' all other prefixes which start with |
| // 'xml' should fail. |
| |
| if (n.nodeType() == ELEMENT || n.nodeType() == ATTR) |
| { |
| Cur c = n.tempCur(); |
| QName name = c.getName(); |
| String uri = name.getNamespaceURI(); |
| String local = name.getLocalPart(); |
| |
| prefix = validatePrefix( prefix, uri, local, n.nodeType() == ATTR ); |
| |
| c.setName( n.locale().makeQName( uri, local, prefix ) ); |
| |
| c.release(); |
| } |
| else |
| validatePrefix( prefix, "", "", false ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static String _node_getPrefix ( Dom n ) |
| { |
| QName name = n.getQName(); |
| return name == null ? "" : name.getPrefix(); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static String _node_getNodeName ( Dom n ) |
| { |
| switch ( n.nodeType() ) |
| { |
| case CDATA : return "#cdata-section"; |
| case COMMENT : return "#comment"; |
| case DOCFRAG : return "#document-fragment"; |
| case DOCUMENT : return "#document"; |
| case PROCINST : return n.getQName().getLocalPart(); |
| case TEXT : return "#text"; |
| |
| case ATTR : |
| case ELEMENT : |
| { |
| QName name = n.getQName(); |
| String prefix = name.getPrefix(); |
| return prefix.length() == 0 ? name.getLocalPart() : prefix + ":" + name.getLocalPart(); |
| } |
| |
| case DOCTYPE : |
| case ENTITY : |
| case ENTITYREF : |
| case NOTATION : |
| throw new RuntimeException( "Not impl" ); |
| |
| default : throw new RuntimeException( "Unknown node type" ); |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static short _node_getNodeType ( Dom n ) |
| { |
| return (short) n.nodeType(); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static void _node_setNodeValue ( Dom n, String nodeValue ) |
| { |
| Locale l = n.locale(); |
| |
| if (l.noSync()) { l.enter(); try { node_setNodeValue( n, nodeValue ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { node_setNodeValue( n, nodeValue ); } finally { l.exit(); } } |
| } |
| |
| public static void node_setNodeValue ( Dom n, String nodeValue ) |
| { |
| if (nodeValue == null) |
| nodeValue = ""; |
| |
| switch ( n.nodeType() ) |
| { |
| case TEXT : |
| case CDATA : |
| { |
| CharNode cn = (CharNode) n; |
| |
| Cur c; |
| |
| if ((c = cn.tempCur()) != null) |
| { |
| c.moveChars( null, cn._cch ); |
| c.insertChars( nodeValue, 0, cn._cch = nodeValue.length() ); |
| c.release(); |
| } |
| else |
| { |
| cn._src = nodeValue; |
| cn._off = 0; |
| cn._cch = nodeValue.length(); |
| } |
| |
| break; |
| } |
| |
| case ATTR : |
| { |
| // Try to set an exisiting text node to contain the new value |
| |
| NodeList children = ((Node) n).getChildNodes(); |
| |
| while ( children.getLength() > 1 ) |
| node_removeChild( n, (Dom) children.item( 1 ) ); |
| |
| if (children.getLength() == 0) |
| { |
| TextNode tn = n.locale().createTextNode(); |
| tn._src = nodeValue; |
| tn._off = 0; |
| tn._cch = nodeValue.length(); |
| |
| node_insertBefore( n, tn, null ); |
| } |
| else |
| { |
| assert children.getLength() == 1; |
| children.item( 0 ).setNodeValue( nodeValue ); |
| } |
| |
| break; |
| } |
| |
| case PROCINST : |
| case COMMENT : |
| { |
| Cur c = n.tempCur(); |
| c.next(); |
| |
| c.getChars( -1 ); |
| c.moveChars( null, c._cchSrc ); |
| c.insertChars( nodeValue, 0, nodeValue.length() ); |
| |
| c.release(); |
| |
| break; |
| } |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static String _node_getNodeValue ( Dom n ) |
| { |
| Locale l = n.locale(); |
| |
| if (l.noSync()) { l.enter(); try { return node_getNodeValue( n ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return node_getNodeValue( n ); } finally { l.exit(); } } |
| } |
| |
| public static String node_getNodeValue ( Dom n ) |
| { |
| String s = null; |
| |
| switch ( n.nodeType() ) |
| { |
| case ATTR : |
| case PROCINST : |
| case COMMENT : |
| { |
| Cur c = n.tempCur(); |
| s = c.getValueAsString(); |
| c.release(); |
| |
| break; |
| } |
| |
| case TEXT : |
| case CDATA : |
| { |
| CharNode node = (CharNode) n; |
| |
| Cur c; |
| |
| if ((c = node.tempCur()) == null) |
| s = CharUtil.getString( node._src, node._off, node._cch ); |
| else |
| { |
| s = c.getString( node._cch ); |
| c.release(); |
| } |
| |
| break; |
| } |
| } |
| |
| return s; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Object _node_getUserData ( Dom n, String key ) |
| { |
| throw new RuntimeException( "DOM Level 3 Not implemented" ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Object _node_setUserData ( Dom n, String key, Object data, UserDataHandler handler ) |
| { |
| throw new RuntimeException( "DOM Level 3 Not implemented" ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Object _node_getFeature ( Dom n, String feature, String version ) |
| { |
| throw new RuntimeException( "DOM Level 3 Not implemented" ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static boolean _node_isEqualNode ( Dom n, Node arg ) |
| { |
| throw new RuntimeException( "DOM Level 3 Not implemented" ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static boolean _node_isSameNode ( Dom n, Node arg ) |
| { |
| throw new RuntimeException( "DOM Level 3 Not implemented" ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static String _node_lookupNamespaceURI ( Dom n, String prefix ) |
| { |
| throw new RuntimeException( "DOM Level 3 Not implemented" ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static boolean _node_isDefaultNamespace ( Dom n, String namespaceURI ) |
| { |
| throw new RuntimeException( "DOM Level 3 Not implemented" ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static String _node_lookupPrefix ( Dom n, String namespaceURI ) |
| { |
| throw new RuntimeException( "DOM Level 3 Not implemented" ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static void _node_setTextContent ( Dom n, String textContent ) |
| { |
| throw new RuntimeException( "DOM Level 3 Not implemented" ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static String _node_getTextContent ( Dom n ) |
| { |
| throw new RuntimeException( "DOM Level 3 Not implemented" ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static short _node_compareDocumentPosition ( Dom n, Node other ) |
| { |
| throw new RuntimeException( "DOM Level 3 Not implemented" ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static String _node_getBaseURI ( Dom n ) |
| { |
| throw new RuntimeException( "DOM Level 3 Not implemented" ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Node _childNodes_item ( Dom n, int i ) |
| { |
| Locale l = n.locale(); |
| |
| Dom d; |
| |
| if (l.noSync()) { l.enter(); try { d = childNodes_item( n, i ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { d = childNodes_item( n, i ); } finally { l.exit(); } } |
| |
| return (Node) d; |
| } |
| |
| public static Dom childNodes_item ( Dom n, int i ) |
| { |
| if (i < 0) |
| return null; |
| |
| switch ( n.nodeType() ) |
| { |
| case TEXT : |
| case CDATA : |
| case PROCINST : |
| case COMMENT : |
| return null; |
| |
| case ENTITYREF : |
| throw new RuntimeException( "Not impl" ); |
| |
| case ENTITY : |
| case DOCTYPE : |
| case NOTATION : |
| throw new RuntimeException( "Not impl" ); |
| |
| case ELEMENT : |
| case DOCUMENT : |
| case DOCFRAG : |
| case ATTR : |
| break; |
| } |
| |
| // TODO - make a couple of caches in master which can cache the |
| // last child for a given index for a given node. Need to so |
| // one may iterate efficiently over to lists |
| |
| // *Really* inefficient impl for now |
| |
| for ( Dom c = node_getFirstChild( n ) ; c != null ; c = node_getNextSibling( c ) ) |
| if (i-- == 0) |
| return c; |
| |
| return null; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static int _childNodes_getLength ( Dom n ) |
| { |
| Locale l = n.locale(); |
| |
| if (l.noSync()) { l.enter(); try { return childNodes_getLength( n ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return childNodes_getLength( n ); } finally { l.exit(); } } |
| } |
| |
| public static int childNodes_getLength ( Dom n ) |
| { |
| switch ( n.nodeType() ) |
| { |
| case TEXT : |
| case CDATA : |
| case PROCINST : |
| case COMMENT : |
| return 0; |
| |
| case ENTITYREF : |
| throw new RuntimeException( "Not impl" ); |
| |
| case ENTITY : |
| case DOCTYPE : |
| case NOTATION : |
| throw new RuntimeException( "Not impl" ); |
| |
| case ELEMENT : |
| case DOCUMENT : |
| case DOCFRAG : |
| case ATTR : |
| break; |
| } |
| |
| // TODO - make a couple of caches in master which can cache the |
| // last child for a given index for a given node. Need to so |
| // one may iterate efficiently over to lists |
| |
| // *Really* inefficient impl for now |
| |
| int len = 0; |
| |
| for ( Dom c = node_getFirstChild( n ) ; c != null ; c = node_getNextSibling( c ) ) |
| len++; |
| |
| return len; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static String _element_getTagName ( Dom e ) |
| { |
| return _node_getNodeName( e ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Attr _element_getAttributeNode ( Dom e, String name ) |
| { |
| return (Attr) _attributes_getNamedItem( e, name ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Attr _element_getAttributeNodeNS ( Dom e, String uri, String local ) |
| { |
| return (Attr) _attributes_getNamedItemNS( e, uri, local ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Attr _element_setAttributeNode ( Dom e, Attr newAttr ) |
| { |
| return (Attr) _attributes_setNamedItem( e, newAttr ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Attr _element_setAttributeNodeNS ( Dom e, Attr newAttr ) |
| { |
| return (Attr) _attributes_setNamedItemNS( e, newAttr ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static String _element_getAttribute ( Dom e, String name ) |
| { |
| Node a = _attributes_getNamedItem( e, name ); |
| return a == null ? "" : a.getNodeValue(); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static String _element_getAttributeNS ( Dom e, String uri, String local ) |
| { |
| Node a = _attributes_getNamedItemNS( e, uri, local ); |
| return a == null ? "" : a.getNodeValue(); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static boolean _element_hasAttribute ( Dom e, String name ) |
| { |
| return _attributes_getNamedItem( e, name ) != null; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static boolean _element_hasAttributeNS ( Dom e, String uri, String local ) |
| { |
| return _attributes_getNamedItemNS( e, uri, local ) != null; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static void _element_removeAttribute ( Dom e, String name ) |
| { |
| try |
| { |
| _attributes_removeNamedItem( e, name ); |
| } |
| catch ( NotFoundErr ex ) |
| { |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static void _element_removeAttributeNS ( Dom e, String uri, String local ) |
| { |
| try |
| { |
| _attributes_removeNamedItemNS( e, uri, local ); |
| } |
| catch ( NotFoundErr ex ) |
| { |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Attr _element_removeAttributeNode ( Dom e, Attr oldAttr ) |
| { |
| if (oldAttr == null) |
| throw new NotFoundErr( "Attribute to remove is null" ); |
| |
| if (oldAttr.getOwnerElement() != e) |
| throw new NotFoundErr( "Attribute to remove does not belong to this element" ); |
| |
| return (Attr) _attributes_removeNamedItem( e, oldAttr.getNodeName() ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static void _element_setAttribute ( Dom e, String name, String value ) |
| { |
| // TODO - validate all attr/element names in all apprpraite |
| // methdos |
| |
| Locale l = e.locale(); |
| |
| if (l.noSync()) { l.enter(); try { element_setAttribute( e, name, value ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { element_setAttribute( e, name, value ); } finally { l.exit(); } } |
| } |
| |
| public static void element_setAttribute ( Dom e, String name, String value ) |
| { |
| Dom a = attributes_getNamedItem( e, name ); |
| |
| if (a == null) |
| { |
| a = document_createAttribute( node_getOwnerDocument( e ), name ); |
| attributes_setNamedItem( e, a ); |
| } |
| |
| node_setNodeValue( a, value ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static void _element_setAttributeNS ( Dom e, String uri, String qName, String value ) |
| { |
| Locale l = e.locale(); |
| |
| if (l.noSync()) { l.enter(); try { element_setAttributeNS( e, uri, qName, value ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { element_setAttributeNS( e, uri, qName, value ); } finally { l.exit(); } } |
| } |
| |
| public static void element_setAttributeNS ( Dom e, String uri, String qName, String value ) |
| { |
| QName name = e.locale().makeQualifiedQName( uri, qName ); |
| String local = name.getLocalPart(); |
| String prefix = validatePrefix( name.getPrefix(), uri, local, true ); |
| |
| Dom a = attributes_getNamedItemNS( e, uri, local ); |
| |
| if (a == null) |
| { |
| a = document_createAttributeNS( node_getOwnerDocument( e ), uri, local ); |
| attributes_setNamedItemNS( e, a ); |
| } |
| |
| node_setPrefix( a, prefix ); |
| node_setNodeValue( a, value ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static NodeList _element_getElementsByTagName ( Dom e, String name ) |
| { |
| Locale l = e.locale(); |
| |
| NodeList nl; |
| |
| if (l.noSync()) { l.enter(); try { nl = element_getElementsByTagName( e, name ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { nl = element_getElementsByTagName( e, name ); } finally { l.exit(); } } |
| |
| return nl; |
| |
| } |
| public static NodeList element_getElementsByTagName ( Dom e, String name ) |
| { |
| return new ElementsByTagNameNodeList( e, name ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static NodeList _element_getElementsByTagNameNS ( Dom e, String uri, String local ) |
| { |
| Locale l = e.locale(); |
| |
| NodeList nl; |
| |
| if (l.noSync()) { l.enter(); try { nl = element_getElementsByTagNameNS( e, uri, local ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { nl = element_getElementsByTagNameNS( e, uri, local ); } finally { l.exit(); } } |
| |
| return nl; |
| } |
| |
| public static NodeList element_getElementsByTagNameNS ( Dom e, String uri, String local ) |
| { |
| return new ElementsByTagNameNSNodeList( e, uri, local ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static int _attributes_getLength ( Dom e ) |
| { |
| Locale l = e.locale(); |
| |
| if (l.noSync()) { l.enter(); try { return attributes_getLength( e ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return attributes_getLength( e ); } finally { l.exit(); } } |
| } |
| |
| public static int attributes_getLength ( Dom e ) |
| { |
| Cur c = e.tempCur(); |
| |
| int n = 0; |
| |
| if (c.toFirstAttr()) |
| { |
| for ( ; ; ) |
| { |
| n++; |
| |
| if (!c.toNextSibling()) |
| break; |
| } |
| } |
| |
| c.release(); |
| |
| return n; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Node _attributes_setNamedItem ( Dom e, Node attr ) |
| { |
| Locale l = e.locale(); |
| |
| if (attr == null) |
| throw new IllegalArgumentException( "Attr to set is null" ); |
| |
| Dom a; |
| |
| if (!(attr instanceof Dom) || (a = (Dom) attr).locale() != l) |
| throw new WrongDocumentErr( "Attr to set is from another document" ); |
| |
| Dom oldA; |
| |
| if (l.noSync()) { l.enter(); try { oldA = attributes_setNamedItem( e, a ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { oldA = attributes_setNamedItem( e, a ); } finally { l.exit(); } } |
| |
| return (Node) oldA; |
| } |
| |
| public static Dom attributes_setNamedItem ( Dom e, Dom a ) |
| { |
| if (attr_getOwnerElement( a ) != null) |
| throw new InuseAttributeError(); |
| |
| if (a.nodeType() != ATTR) |
| throw new HierarchyRequestErr( "Node is not an attribute" ); |
| |
| String name = _node_getNodeName( a ); |
| Dom oldAttr = null; |
| |
| Cur c = e.tempCur(); |
| |
| if (c.toFirstAttr()) |
| { |
| while ( c.isAttr() ) |
| { |
| Dom aa = c.getDom(); |
| |
| boolean hasNext = c.toNextSibling(); |
| |
| if (_node_getNodeName( aa ).equals( name )) |
| { |
| if (oldAttr == null) |
| oldAttr = aa; |
| else |
| removeNode( aa ); |
| } |
| |
| if (!hasNext) |
| break; |
| } |
| } |
| |
| Cur ac = a.tempCur(); |
| |
| if (oldAttr == null) |
| { |
| c.moveToDom( e ); |
| |
| if (!c.toFirstChild()) |
| c.toEnd(); |
| |
| ac.moveNode( c ); |
| } |
| else |
| { |
| c.moveToDom( oldAttr ); |
| ac.moveNode( c ); |
| removeNode( oldAttr ); |
| } |
| |
| c.release(); |
| ac.release(); |
| |
| return oldAttr; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Node _attributes_getNamedItem ( Dom e, String name ) |
| { |
| Locale l = e.locale(); |
| |
| Dom n; |
| |
| if (l.noSync()) { l.enter(); try { n = attributes_getNamedItem( e, name ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { n = attributes_getNamedItem( e, name ); } finally { l.exit(); } } |
| |
| return (Node) n; |
| } |
| |
| public static Dom attributes_getNamedItem ( Dom e, String name ) |
| { |
| Dom a = null; |
| |
| Cur c = e.tempCur(); |
| |
| if (c.toFirstAttr()) |
| { |
| for ( ; ; ) |
| { |
| Dom d = c.getDom(); |
| |
| if (_node_getNodeName( d ).equals( name )) |
| { |
| a = d; |
| break; |
| } |
| |
| if (!c.toNextSibling()) |
| break; |
| } |
| } |
| |
| c.release(); |
| |
| return a; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Node _attributes_getNamedItemNS ( Dom e, String uri, String local ) |
| { |
| Locale l = e.locale(); |
| |
| Dom n; |
| |
| if (l.noSync()) { l.enter(); try { n = attributes_getNamedItemNS( e, uri, local ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { n = attributes_getNamedItemNS( e, uri, local ); } finally { l.exit(); } } |
| |
| return (Node) n; |
| } |
| |
| public static Dom attributes_getNamedItemNS ( Dom e, String uri, String local ) |
| { |
| if (uri == null) |
| uri = ""; |
| |
| Dom a = null; |
| |
| Cur c = e.tempCur(); |
| |
| if (c.toFirstAttr()) |
| { |
| for ( ; ; ) |
| { |
| Dom d = c.getDom(); |
| |
| QName n = d.getQName(); |
| |
| if (n.getNamespaceURI().equals( uri ) && n.getLocalPart().equals( local )) |
| { |
| a = d; |
| break; |
| } |
| |
| if (!c.toNextSibling()) |
| break; |
| } |
| } |
| |
| c.release(); |
| |
| return a; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Node _attributes_removeNamedItem ( Dom e, String name ) |
| { |
| Locale l = e.locale(); |
| |
| Dom n; |
| |
| if (l.noSync()) { l.enter(); try { n = attributes_removeNamedItem( e, name ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { n = attributes_removeNamedItem( e, name ); } finally { l.exit(); } } |
| |
| return (Node) n; |
| } |
| |
| public static Dom attributes_removeNamedItem ( Dom e, String name ) |
| { |
| Dom oldAttr = null; |
| |
| Cur c = e.tempCur(); |
| |
| if (c.toFirstAttr()) |
| { |
| while ( c.isAttr() ) |
| { |
| Dom aa = c.getDom(); |
| |
| boolean hasNext = c.toNextSibling(); |
| |
| if (_node_getNodeName( aa ).equals( name )) |
| { |
| if (oldAttr == null) |
| oldAttr = aa; |
| |
| removeNode( aa ); |
| } |
| |
| if (!hasNext) |
| break; |
| } |
| } |
| |
| c.release(); |
| |
| if (oldAttr == null) |
| throw new NotFoundErr( "Named item not found: " + name ); |
| |
| return oldAttr; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Node _attributes_removeNamedItemNS ( Dom e, String uri, String local ) |
| { |
| Locale l = e.locale(); |
| |
| Dom n; |
| |
| if (l.noSync()) { l.enter(); try { n = attributes_removeNamedItemNS( e, uri, local ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { n = attributes_removeNamedItemNS( e, uri, local ); } finally { l.exit(); } } |
| |
| return (Node) n; |
| } |
| |
| public static Dom attributes_removeNamedItemNS ( Dom e, String uri, String local ) |
| { |
| if (uri == null) |
| uri = ""; |
| |
| Dom oldAttr = null; |
| |
| Cur c = e.tempCur(); |
| |
| if (c.toFirstAttr()) |
| { |
| while ( c.isAttr() ) |
| { |
| Dom aa = c.getDom(); |
| |
| boolean hasNext = c.toNextSibling(); |
| |
| QName qn = aa.getQName(); |
| |
| if (qn.getNamespaceURI().equals( uri ) && qn.getLocalPart().equals( local )) |
| { |
| if (oldAttr == null) |
| oldAttr = aa; |
| |
| removeNode( aa ); |
| } |
| |
| if (!hasNext) |
| break; |
| } |
| } |
| |
| c.release(); |
| |
| if (oldAttr == null) |
| throw new NotFoundErr( "Named item not found: uri=" + uri + ", local=" + local ); |
| |
| return oldAttr; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Node _attributes_setNamedItemNS ( Dom e, Node attr ) |
| { |
| Locale l = e.locale(); |
| |
| if (attr == null) |
| throw new IllegalArgumentException( "Attr to set is null" ); |
| |
| Dom a; |
| |
| if (!(attr instanceof Dom) || (a = (Dom) attr).locale() != l) |
| throw new WrongDocumentErr( "Attr to set is from another document" ); |
| |
| Dom oldA; |
| |
| if (l.noSync()) { l.enter(); try { oldA = attributes_setNamedItemNS( e, a ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { oldA = attributes_setNamedItemNS( e, a ); } finally { l.exit(); } } |
| |
| return (Node) oldA; |
| } |
| |
| public static Dom attributes_setNamedItemNS ( Dom e, Dom a ) |
| { |
| Dom owner = attr_getOwnerElement( a ); |
| |
| if (owner == e) |
| return a; |
| |
| if (owner != null) |
| throw new InuseAttributeError(); |
| |
| if (a.nodeType() != ATTR) |
| throw new HierarchyRequestErr( "Node is not an attribute" ); |
| |
| QName name = a.getQName(); |
| Dom oldAttr = null; |
| |
| Cur c = e.tempCur(); |
| |
| if (c.toFirstAttr()) |
| { |
| while ( c.isAttr() ) |
| { |
| Dom aa = c.getDom(); |
| |
| boolean hasNext = c.toNextSibling(); |
| |
| if (aa.getQName().equals( name )) |
| { |
| if (oldAttr == null) |
| oldAttr = aa; |
| else |
| removeNode( aa ); |
| } |
| |
| if (!hasNext) |
| break; |
| } |
| } |
| |
| Cur ac = a.tempCur(); |
| |
| if (oldAttr == null) |
| { |
| c.moveToDom( e ); |
| c.next(); |
| ac.moveNode( c ); |
| } |
| else |
| { |
| c.moveToDom( oldAttr ); |
| ac.moveNode( c ); |
| removeNode( oldAttr ); |
| } |
| |
| c.release(); |
| ac.release(); |
| |
| return oldAttr; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Node _attributes_item ( Dom e, int index ) |
| { |
| Locale l = e.locale(); |
| |
| Dom a; |
| |
| if (l.noSync()) { l.enter(); try { a = attributes_item( e, index ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { a = attributes_item( e, index ); } finally { l.exit(); } } |
| |
| return (Node) a; |
| } |
| |
| public static Dom attributes_item ( Dom e, int index ) |
| { |
| if (index < 0) |
| return null; |
| |
| Cur c = e.tempCur(); |
| |
| Dom a = null; |
| |
| if (c.toFirstAttr()) |
| { |
| for ( ; ; ) |
| { |
| if (index-- == 0) |
| { |
| a = c.getDom(); |
| break; |
| } |
| |
| if (!c.toNextSibling()) |
| break; |
| } |
| } |
| |
| c.release(); |
| |
| return a; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static String _processingInstruction_getData ( Dom p ) |
| { |
| return _node_getNodeValue( p ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static String _processingInstruction_getTarget ( Dom p ) |
| { |
| return _node_getNodeName( p ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static void _processingInstruction_setData ( Dom p, String data ) |
| { |
| _node_setNodeValue( p, data ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static boolean _attr_getSpecified ( Dom a ) |
| { |
| // Can't tell the difference |
| return true; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Element _attr_getOwnerElement ( Dom a ) |
| { |
| Locale l = a.locale(); |
| |
| Dom e; |
| |
| if (l.noSync()) { l.enter(); try { e = attr_getOwnerElement( a ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { e = attr_getOwnerElement( a ); } finally { l.exit(); } } |
| |
| return (Element) e; |
| } |
| |
| public static Dom attr_getOwnerElement ( Dom n ) |
| { |
| Cur c = n.tempCur(); |
| |
| if (!c.toParentRaw()) |
| return null; |
| |
| Dom p = c.getDom(); |
| |
| c.release(); |
| |
| return p; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static void _characterData_appendData ( Dom cd, String arg ) |
| { |
| // TODO - fix this *really* cheesy/bad/lousy perf impl |
| // also fix all the funcitons which follow |
| |
| if (arg != null && arg.length() != 0) |
| _node_setNodeValue( cd, _node_getNodeValue( cd ) + arg ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static void _characterData_deleteData ( Dom c, int offset, int count ) |
| { |
| String s = _characterData_getData( c ); |
| |
| if (offset < 0 || offset > s.length() || count < 0) |
| throw new IndexSizeError(); |
| |
| if (offset + count > s.length()) |
| count = s.length() - offset; |
| |
| if (count > 0) |
| _characterData_setData( c, s.substring( 0, offset ) + s.substring( offset + count ) ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static String _characterData_getData ( Dom c ) |
| { |
| return _node_getNodeValue( c ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static int _characterData_getLength ( Dom c ) |
| { |
| return _characterData_getData( c ).length(); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static void _characterData_insertData ( Dom c, int offset, String arg ) |
| { |
| String s = _characterData_getData( c ); |
| |
| if (offset < 0 || offset > s.length()) |
| throw new IndexSizeError(); |
| |
| if (arg != null && arg.length() > 0) |
| _characterData_setData( c, s.substring( 0, offset ) + arg + s.substring( offset ) ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static void _characterData_replaceData ( Dom c, int offset, int count, String arg ) |
| { |
| String s = _characterData_getData( c ); |
| |
| if (offset < 0 || offset > s.length() || count < 0) |
| throw new IndexSizeError(); |
| |
| if (offset + count > s.length()) |
| count = s.length() - offset; |
| |
| if (count > 0) |
| { |
| _characterData_setData( |
| c, s.substring( 0, offset ) + (arg == null ? "" : arg) |
| + s.substring( offset + count ) ); |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static void _characterData_setData ( Dom c, String data ) |
| { |
| _node_setNodeValue( c, data ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static String _characterData_substringData ( Dom c, int offset, int count ) |
| { |
| String s = _characterData_getData( c ); |
| |
| if (offset < 0 || offset > s.length() || count < 0) |
| throw new IndexSizeError(); |
| |
| if (offset + count > s.length()) |
| count = s.length() - offset; |
| |
| return s.substring( offset, offset + count ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Text _text_splitText ( Dom t, int offset ) |
| { |
| assert t.nodeType() == TEXT; |
| |
| String s = _characterData_getData( t ); |
| |
| if (offset < 0 || offset > s.length()) |
| throw new IndexSizeError(); |
| |
| _characterData_deleteData( t, offset, s.length() - offset ); |
| |
| // Don't need to pass a doc here, any node will do.. |
| |
| Dom t2 = (Dom) _document_createTextNode( t, s.substring( offset ) ); |
| |
| Dom p = (Dom) _node_getParentNode( t ); |
| |
| if (p != null) |
| _node_insertBefore( p, (Text) t2, _node_getNextSibling( t ) ); |
| |
| return (Text) t2; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static String _text_getWholeText ( Dom t ) |
| { |
| throw new RuntimeException( "DOM Level 3 Not implemented" ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static boolean _text_isElementContentWhitespace ( Dom t ) |
| { |
| throw new RuntimeException( "DOM Level 3 Not implemented" ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static Text _text_replaceWholeText ( Dom t, String content ) |
| { |
| throw new RuntimeException( "DOM Level 3 Not implemented" ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static XMLStreamReader _getXmlStreamReader ( Dom n ) |
| { |
| Locale l = n.locale(); |
| |
| if (l.noSync()) { l.enter(); try { return getXmlStreamReader( n ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return getXmlStreamReader( n ); } finally { l.exit(); } } |
| } |
| |
| public static XMLStreamReader getXmlStreamReader ( Dom n ) |
| { |
| XMLStreamReader xs; |
| |
| switch ( n.nodeType() ) |
| { |
| case DOCUMENT : |
| case DOCFRAG : |
| case ATTR : |
| case ELEMENT : |
| case PROCINST : |
| case COMMENT : |
| { |
| Cur c = n.tempCur(); |
| xs = Jsr173.newXmlStreamReader( c, null ); |
| c.release(); |
| break; |
| } |
| |
| case TEXT : |
| case CDATA : |
| { |
| CharNode cn = (CharNode) n; |
| |
| Cur c; |
| |
| if ((c = cn.tempCur()) == null) |
| { |
| c = n.locale().tempCur(); |
| |
| xs = Jsr173.newXmlStreamReader( c, cn._src, cn._off, cn._cch ); |
| } |
| else |
| { |
| xs = |
| Jsr173.newXmlStreamReader( |
| c , c.getChars( cn._cch ), c._offSrc, c._cchSrc ); |
| |
| } |
| |
| c.release(); |
| |
| break; |
| } |
| |
| case ENTITYREF : |
| case ENTITY : |
| case DOCTYPE : |
| case NOTATION : |
| throw new RuntimeException( "Not impl" ); |
| |
| default : throw new RuntimeException( "Unknown kind" ); |
| } |
| |
| return xs; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| public static XmlCursor _getXmlCursor ( Dom n ) |
| { |
| Locale l = n.locale(); |
| |
| if (l.noSync()) { l.enter(); try { return getXmlCursor( n ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return getXmlCursor( n ); } finally { l.exit(); } } |
| } |
| |
| public static XmlCursor getXmlCursor ( Dom n ) |
| { |
| Cur c = n.tempCur(); |
| |
| Cursor xc = new Cursor( c ); |
| |
| c.release(); |
| |
| return xc; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| static abstract class CharNode implements Dom, Node, CharacterData |
| { |
| public CharNode ( Locale l ) |
| { |
| _locale = l; |
| } |
| |
| public QName getQName ( ) |
| { |
| return null; |
| } |
| |
| public Locale locale ( ) |
| { |
| return _locale; |
| } |
| |
| public Cur tempCur ( ) |
| { |
| Cur c; |
| |
| if (_src instanceof Dom) |
| { |
| c = _locale.tempCur(); |
| c.moveToCharNode( this ); |
| } |
| else |
| c = null; |
| |
| return c; |
| } |
| |
| public static boolean isOnList ( CharNode nodes, CharNode node ) |
| { |
| assert node != null; |
| |
| for ( CharNode cn = nodes ; cn != null ; cn = cn._next ) |
| if (cn == node) |
| return true; |
| |
| return false; |
| } |
| |
| public static CharNode remove ( CharNode nodes, CharNode node ) |
| { |
| assert isOnList( nodes, node ); |
| |
| if (nodes == node) |
| nodes = node._next; |
| else |
| node._prev._next = node._next; |
| |
| if (node._next != null) |
| node._next._prev = node._prev; |
| |
| node._prev = node._next = null; |
| |
| return nodes; |
| } |
| |
| public static CharNode insertNode ( CharNode nodes, CharNode newNode, CharNode before ) |
| { |
| assert !isOnList( nodes, newNode ); |
| assert before == null || isOnList( nodes, before ); |
| assert newNode != null; |
| assert newNode._prev == null && newNode._next == null; |
| |
| if (nodes == null) |
| { |
| assert before == null; |
| nodes = newNode; |
| } |
| else if (nodes == before) |
| { |
| nodes._prev = newNode; |
| newNode._next = nodes; |
| nodes = newNode; |
| } |
| else |
| { |
| CharNode n = nodes; |
| |
| while ( n._next != before ) |
| n = n._next; |
| |
| if ((newNode._next = n._next) != null) |
| n._next._prev = newNode; |
| |
| newNode._prev = n; |
| n._next = newNode; |
| } |
| |
| return nodes; |
| } |
| |
| public static CharNode appendNode ( CharNode nodes, CharNode newNode ) |
| { |
| return insertNode( nodes, newNode, null ); |
| } |
| |
| public static CharNode appendNodes ( CharNode nodes, CharNode newNodes ) |
| { |
| assert newNodes != null; |
| assert newNodes._prev == null; |
| |
| if (nodes == null) |
| return newNodes; |
| |
| CharNode n = nodes; |
| |
| while ( n._next != null ) |
| n = n._next; |
| |
| n._next = newNodes; |
| newNodes._prev = n; |
| |
| return nodes; |
| } |
| |
| public static CharNode copyNodes ( CharNode nodes, Object newSrc ) |
| { |
| CharNode newNodes = null; |
| |
| for ( CharNode n = null ; nodes != null ; nodes = nodes._next ) |
| { |
| CharNode newNode; |
| |
| if (nodes instanceof TextNode) |
| newNode = nodes._locale.createTextNode(); |
| else |
| newNode = nodes._locale.createCdataNode(); |
| |
| // How to deal with entity refs?? |
| |
| newNode._src = newSrc; |
| newNode._off = nodes._off; |
| newNode._cch = nodes._cch; |
| |
| if (newNodes == null) |
| newNodes = newNode; |
| |
| if (n != null) |
| { |
| n._next = newNode; |
| newNode._prev = n; |
| } |
| |
| n = newNode; |
| } |
| |
| return newNodes; |
| } |
| |
| public void dump ( PrintStream o, Object ref ) |
| { |
| if (_src instanceof Dom) |
| ((Dom) _src).dump( o, ref ); |
| else |
| o.println( "Lonely CharNode: \"" + CharUtil.getString( _src, _off, _cch ) + "\"" ); |
| } |
| |
| public void dump ( PrintStream o ) |
| { |
| dump( o, (Object) this ); |
| } |
| |
| public void dump ( ) |
| { |
| dump( System.out ); |
| } |
| |
| public Node appendChild ( Node newChild ) { return DomImpl._node_appendChild( this, newChild ); } |
| public Node cloneNode ( boolean deep ) { return DomImpl._node_cloneNode( this, deep ); } |
| public NamedNodeMap getAttributes ( ) { return null; } |
| public NodeList getChildNodes ( ) { return DomImpl._emptyNodeList; } |
| public Node getParentNode ( ) { return DomImpl._node_getParentNode( this ); } |
| public Node removeChild ( Node oldChild ) { return DomImpl._node_removeChild( this, oldChild ); } |
| public Node getFirstChild ( ) { return DomImpl._node_getFirstChild( this ); } |
| public Node getLastChild ( ) { return DomImpl._node_getLastChild( this ); } |
| public String getLocalName ( ) { return DomImpl._node_getLocalName( this ); } |
| public String getNamespaceURI ( ) { return DomImpl._node_getNamespaceURI( this ); } |
| public Node getNextSibling ( ) { return DomImpl._node_getNextSibling( this ); } |
| public String getNodeName ( ) { return DomImpl._node_getNodeName( this ); } |
| public short getNodeType ( ) { return DomImpl._node_getNodeType( this ); } |
| public String getNodeValue ( ) { return DomImpl._node_getNodeValue( this ); } |
| public Document getOwnerDocument ( ) { return DomImpl._node_getOwnerDocument( this ); } |
| public String getPrefix ( ) { return DomImpl._node_getPrefix( this ); } |
| public Node getPreviousSibling ( ) { return DomImpl._node_getPreviousSibling( this ); } |
| public boolean hasAttributes ( ) { return DomImpl._node_hasAttributes( this ); } |
| public boolean hasChildNodes ( ) { return DomImpl._node_hasChildNodes( this ); } |
| public Node insertBefore ( Node newChild, Node refChild ) { return DomImpl._node_insertBefore( this, newChild, refChild ); } |
| public boolean isSupported ( String feature, String version ) { return DomImpl._node_isSupported( this, feature, version ); } |
| public void normalize ( ) { DomImpl._node_normalize( this ); } |
| public Node replaceChild ( Node newChild, Node oldChild ) { return DomImpl._node_replaceChild( this, newChild, oldChild ); } |
| public void setNodeValue ( String nodeValue ) { DomImpl._node_setNodeValue( this, nodeValue ); } |
| public void setPrefix ( String prefix ) { DomImpl._node_setPrefix( this, prefix ); } |
| |
| // DOM Level 3 |
| public Object getUserData ( String key ) { return DomImpl._node_getUserData( this, key ); } |
| public Object setUserData ( String key, Object data, UserDataHandler handler ) { return DomImpl._node_setUserData( this, key, data, handler ); } |
| public Object getFeature ( String feature, String version ) { return DomImpl._node_getFeature( this, feature, version ); } |
| public boolean isEqualNode ( Node arg ) { return DomImpl._node_isEqualNode( this, arg ); } |
| public boolean isSameNode ( Node arg ) { return DomImpl._node_isSameNode( this, arg ); } |
| public String lookupNamespaceURI ( String prefix ) { return DomImpl._node_lookupNamespaceURI( this, prefix ); } |
| public String lookupPrefix ( String namespaceURI ) { return DomImpl._node_lookupPrefix( this, namespaceURI ); } |
| public boolean isDefaultNamespace ( String namespaceURI ) { return DomImpl._node_isDefaultNamespace( this, namespaceURI ); } |
| public void setTextContent ( String textContent ) { DomImpl._node_setTextContent( this, textContent ); } |
| public String getTextContent ( ) { return DomImpl._node_getTextContent( this ); } |
| public short compareDocumentPosition ( Node other ) { return DomImpl._node_compareDocumentPosition( this, other ); } |
| public String getBaseURI ( ) { return DomImpl._node_getBaseURI( this ); } |
| |
| public void appendData ( String arg ) { DomImpl._characterData_appendData( this, arg ); } |
| public void deleteData ( int offset, int count ) { DomImpl._characterData_deleteData( this, offset, count ); } |
| public String getData ( ) { return DomImpl._characterData_getData( this ); } |
| public int getLength ( ) { return DomImpl._characterData_getLength( this ); } |
| public void insertData ( int offset, String arg ) { DomImpl._characterData_insertData( this, offset, arg ); } |
| public void replaceData ( int offset, int count, String arg ) { DomImpl._characterData_replaceData( this, offset, count, arg ); } |
| public void setData ( String data ) { DomImpl._characterData_setData( this, data ); } |
| public String substringData ( int offset, int count ) { return DomImpl._characterData_substringData( this, offset, count ); } |
| |
| Locale _locale; |
| |
| CharNode _next; |
| CharNode _prev; |
| |
| Object _src; |
| int _off; |
| int _cch; |
| } |
| |
| static class TextNode extends CharNode implements Text |
| { |
| TextNode ( Locale l ) |
| { |
| super( l ); |
| } |
| |
| public int nodeType ( ) { return DomImpl.TEXT; } |
| |
| public String name ( ) { return "#text"; } |
| |
| public Text splitText ( int offset ) { return DomImpl._text_splitText ( this, offset ); } |
| public String getWholeText ( ) { return DomImpl._text_getWholeText( this ); } |
| public boolean isElementContentWhitespace ( ) { return DomImpl._text_isElementContentWhitespace( this ); } |
| public Text replaceWholeText ( String content ) { return DomImpl._text_replaceWholeText( this, content ); } |
| } |
| |
| static class CdataNode extends TextNode implements CDATASection |
| { |
| CdataNode ( Locale l ) |
| { |
| super( l ); |
| } |
| |
| public int nodeType ( ) { return DomImpl.CDATA; } |
| |
| public String name ( ) { return "#cdata-section"; } |
| } |
| |
| static class SaajTextNode extends TextNode implements javax.xml.soap.Text |
| { |
| SaajTextNode ( Locale l ) |
| { |
| super( l ); |
| } |
| |
| public boolean isComment ( ) { return DomImpl._soapText_isComment( this ); } |
| |
| public void detachNode ( ) { DomImpl._soapNode_detachNode( this ); } |
| public void recycleNode ( ) { DomImpl._soapNode_recycleNode( this ); } |
| public String getValue ( ) { return DomImpl._soapNode_getValue( this ); } |
| public void setValue ( String value ) { DomImpl._soapNode_setValue( this, value ); } |
| public SOAPElement getParentElement ( ) { return DomImpl._soapNode_getParentElement( this ); } |
| public void setParentElement ( SOAPElement p ) { DomImpl._soapNode_setParentElement( this, p ); } |
| } |
| |
| static class SaajCdataNode extends CdataNode implements javax.xml.soap.Text |
| { |
| public SaajCdataNode ( Locale l ) |
| { |
| super( l ); |
| } |
| |
| public boolean isComment ( ) { return DomImpl._soapText_isComment( this ); } |
| |
| public void detachNode ( ) { DomImpl._soapNode_detachNode( this ); } |
| public void recycleNode ( ) { DomImpl._soapNode_recycleNode( this ); } |
| public String getValue ( ) { return DomImpl._soapNode_getValue( this ); } |
| public void setValue ( String value ) { DomImpl._soapNode_setValue( this, value ); } |
| public SOAPElement getParentElement ( ) { return DomImpl._soapNode_getParentElement( this ); } |
| public void setParentElement ( SOAPElement p ) { DomImpl._soapNode_setParentElement( this, p ); } |
| } |
| |
| // |
| // Soap Text Node |
| // |
| |
| public static boolean _soapText_isComment ( Dom n ) |
| { |
| Locale l = n.locale(); |
| |
| javax.xml.soap.Text text = (javax.xml.soap.Text) n; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapText_isComment( text ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapText_isComment( text ); } finally { l.exit(); } } |
| } |
| |
| // |
| // Soap Node |
| // |
| |
| public static void _soapNode_detachNode ( Dom n ) |
| { |
| Locale l = n.locale(); |
| |
| javax.xml.soap.Node node = (javax.xml.soap.Node) n; |
| |
| if (l.noSync()) { l.enter(); try { l._saaj.soapNode_detachNode( node ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { l._saaj.soapNode_detachNode( node ); } finally { l.exit(); } } |
| } |
| |
| public static void _soapNode_recycleNode ( Dom n ) |
| { |
| Locale l = n.locale(); |
| |
| javax.xml.soap.Node node = (javax.xml.soap.Node) n; |
| |
| if (l.noSync()) { l.enter(); try { l._saaj.soapNode_recycleNode( node ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { l._saaj.soapNode_recycleNode( node ); } finally { l.exit(); } } |
| } |
| |
| public static String _soapNode_getValue ( Dom n ) |
| { |
| Locale l = n.locale(); |
| |
| javax.xml.soap.Node node = (javax.xml.soap.Node) n; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapNode_getValue( node ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapNode_getValue( node ); } finally { l.exit(); } } |
| } |
| |
| public static void _soapNode_setValue ( Dom n, String value ) |
| { |
| Locale l = n.locale(); |
| |
| javax.xml.soap.Node node = (javax.xml.soap.Node) n; |
| |
| if (l.noSync()) { l.enter(); try { l._saaj.soapNode_setValue( node, value ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { l._saaj.soapNode_setValue( node, value ); } finally { l.exit(); } } |
| } |
| |
| public static SOAPElement _soapNode_getParentElement ( Dom n ) |
| { |
| Locale l = n.locale(); |
| |
| javax.xml.soap.Node node = (javax.xml.soap.Node) n; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapNode_getParentElement( node ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapNode_getParentElement( node ); } finally { l.exit(); } } |
| } |
| |
| public static void _soapNode_setParentElement ( Dom n, SOAPElement p ) |
| { |
| Locale l = n.locale(); |
| |
| javax.xml.soap.Node node = (javax.xml.soap.Node) n; |
| |
| if (l.noSync()) { l.enter(); try { l._saaj.soapNode_setParentElement( node, p ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { l._saaj.soapNode_setParentElement( node, p ); } finally { l.exit(); } } |
| } |
| |
| // |
| // Soap Element |
| // |
| |
| public static void _soapElement_removeContents ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPElement se = (SOAPElement) d; |
| |
| if (l.noSync()) { l.enter(); try { l._saaj.soapElement_removeContents( se ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { l._saaj.soapElement_removeContents( se ); } finally { l.exit(); } } |
| } |
| |
| public static String _soapElement_getEncodingStyle ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPElement se = (SOAPElement) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapElement_getEncodingStyle( se ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_getEncodingStyle( se ); } finally { l.exit(); } } |
| } |
| |
| public static void _soapElement_setEncodingStyle ( Dom d, String encodingStyle ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPElement se = (SOAPElement) d; |
| |
| if (l.noSync()) { l.enter(); try { l._saaj.soapElement_setEncodingStyle( se, encodingStyle ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { l._saaj.soapElement_setEncodingStyle( se, encodingStyle ); } finally { l.exit(); } } |
| } |
| |
| public static boolean _soapElement_removeNamespaceDeclaration ( Dom d, String prefix ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPElement se = (SOAPElement) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapElement_removeNamespaceDeclaration( se, prefix ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_removeNamespaceDeclaration( se, prefix ); } finally { l.exit(); } } |
| } |
| |
| public static Iterator _soapElement_getAllAttributes ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPElement se = (SOAPElement) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapElement_getAllAttributes( se ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_getAllAttributes( se ); } finally { l.exit(); } } |
| } |
| |
| public static Iterator _soapElement_getChildElements ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPElement se = (SOAPElement) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapElement_getChildElements( se ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_getChildElements( se ); } finally { l.exit(); } } |
| } |
| |
| public static Iterator _soapElement_getNamespacePrefixes ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPElement se = (SOAPElement) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapElement_getNamespacePrefixes( se ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_getNamespacePrefixes( se ); } finally { l.exit(); } } |
| } |
| |
| public static SOAPElement _soapElement_addAttribute ( Dom d, Name name, String value ) throws SOAPException |
| { |
| Locale l = d.locale(); |
| |
| SOAPElement se = (SOAPElement) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapElement_addAttribute( se, name, value ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_addAttribute( se, name, value ); } finally { l.exit(); } } |
| } |
| |
| public static SOAPElement _soapElement_addChildElement ( Dom d, SOAPElement oldChild ) throws SOAPException |
| { |
| Locale l = d.locale(); |
| |
| SOAPElement se = (SOAPElement) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapElement_addChildElement( se, oldChild ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_addChildElement( se, oldChild ); } finally { l.exit(); } } |
| } |
| |
| public static SOAPElement _soapElement_addChildElement ( Dom d, Name name ) throws SOAPException |
| { |
| Locale l = d.locale(); |
| |
| SOAPElement se = (SOAPElement) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapElement_addChildElement( se, name ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_addChildElement( se, name ); } finally { l.exit(); } } |
| } |
| |
| public static SOAPElement _soapElement_addChildElement ( Dom d, String localName ) throws SOAPException |
| { |
| Locale l = d.locale(); |
| |
| SOAPElement se = (SOAPElement) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapElement_addChildElement( se, localName ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_addChildElement( se, localName ); } finally { l.exit(); } } |
| } |
| |
| public static SOAPElement _soapElement_addChildElement ( Dom d, String localName, String prefix ) throws SOAPException |
| { |
| Locale l = d.locale(); |
| |
| SOAPElement se = (SOAPElement) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapElement_addChildElement( se, localName, prefix ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_addChildElement( se, localName, prefix ); } finally { l.exit(); } } |
| } |
| |
| public static SOAPElement _soapElement_addChildElement ( Dom d, String localName, String prefix, String uri ) throws SOAPException |
| { |
| Locale l = d.locale(); |
| |
| SOAPElement se = (SOAPElement) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapElement_addChildElement( se, localName, prefix, uri ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_addChildElement( se, localName, prefix, uri ); } finally { l.exit(); } } |
| } |
| |
| public static SOAPElement _soapElement_addNamespaceDeclaration ( Dom d, String prefix, String uri ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPElement se = (SOAPElement) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapElement_addNamespaceDeclaration( se, prefix, uri ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_addNamespaceDeclaration( se, prefix, uri ); } finally { l.exit(); } } |
| } |
| |
| public static SOAPElement _soapElement_addTextNode ( Dom d, String data ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPElement se = (SOAPElement) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapElement_addTextNode( se, data ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_addTextNode( se, data ); } finally { l.exit(); } } |
| } |
| |
| public static String _soapElement_getAttributeValue ( Dom d, Name name ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPElement se = (SOAPElement) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapElement_getAttributeValue( se, name ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_getAttributeValue( se, name ); } finally { l.exit(); } } |
| } |
| |
| public static Iterator _soapElement_getChildElements ( Dom d, Name name ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPElement se = (SOAPElement) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapElement_getChildElements( se, name ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_getChildElements( se, name ); } finally { l.exit(); } } |
| } |
| |
| public static Name _soapElement_getElementName ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPElement se = (SOAPElement) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapElement_getElementName( se ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_getElementName( se ); } finally { l.exit(); } } |
| } |
| |
| public static String _soapElement_getNamespaceURI ( Dom d, String prefix ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPElement se = (SOAPElement) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapElement_getNamespaceURI( se, prefix ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_getNamespaceURI( se, prefix ); } finally { l.exit(); } } |
| } |
| |
| public static Iterator _soapElement_getVisibleNamespacePrefixes ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPElement se = (SOAPElement) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapElement_getVisibleNamespacePrefixes( se ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_getVisibleNamespacePrefixes( se ); } finally { l.exit(); } } |
| } |
| |
| public static boolean _soapElement_removeAttribute ( Dom d, Name name ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPElement se = (SOAPElement) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapElement_removeAttribute( se, name ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_removeAttribute( se, name ); } finally { l.exit(); } } |
| } |
| |
| // |
| // Soap Envelope |
| // |
| |
| public static SOAPBody _soapEnvelope_addBody ( Dom d ) throws SOAPException |
| { |
| Locale l = d.locale(); |
| |
| SOAPEnvelope se = (SOAPEnvelope) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapEnvelope_addBody( se ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapEnvelope_addBody( se ); } finally { l.exit(); } } |
| } |
| |
| public static SOAPBody _soapEnvelope_getBody ( Dom d ) throws SOAPException |
| { |
| Locale l = d.locale(); |
| |
| SOAPEnvelope se = (SOAPEnvelope) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapEnvelope_getBody( se ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapEnvelope_getBody( se ); } finally { l.exit(); } } |
| } |
| |
| public static SOAPHeader _soapEnvelope_getHeader ( Dom d ) throws SOAPException |
| { |
| Locale l = d.locale(); |
| |
| SOAPEnvelope se = (SOAPEnvelope) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapEnvelope_getHeader( se ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapEnvelope_getHeader( se ); } finally { l.exit(); } } |
| } |
| |
| public static SOAPHeader _soapEnvelope_addHeader ( Dom d ) throws SOAPException |
| { |
| Locale l = d.locale(); |
| |
| SOAPEnvelope se = (SOAPEnvelope) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapEnvelope_addHeader( se ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapEnvelope_addHeader( se ); } finally { l.exit(); } } |
| } |
| |
| public static Name _soapEnvelope_createName ( Dom d, String localName ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPEnvelope se = (SOAPEnvelope) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapEnvelope_createName( se, localName ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapEnvelope_createName( se, localName ); } finally { l.exit(); } } |
| } |
| |
| public static Name _soapEnvelope_createName ( Dom d, String localName, String prefix, String namespaceURI ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPEnvelope se = (SOAPEnvelope) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapEnvelope_createName( se, localName, prefix, namespaceURI ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapEnvelope_createName( se, localName, prefix, namespaceURI ); } finally { l.exit(); } } |
| } |
| |
| // |
| // Soap Header |
| // |
| |
| public static Iterator soapHeader_examineAllHeaderElements ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPHeader sh = (SOAPHeader) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapHeader_examineAllHeaderElements( sh ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapHeader_examineAllHeaderElements( sh ); } finally { l.exit(); } } |
| } |
| |
| public static Iterator soapHeader_extractAllHeaderElements ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPHeader sh = (SOAPHeader) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapHeader_extractAllHeaderElements( sh ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapHeader_extractAllHeaderElements( sh ); } finally { l.exit(); } } |
| } |
| |
| public static Iterator soapHeader_examineHeaderElements ( Dom d, String actor ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPHeader sh = (SOAPHeader) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapHeader_examineHeaderElements( sh, actor ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapHeader_examineHeaderElements( sh, actor ); } finally { l.exit(); } } |
| } |
| |
| public static Iterator soapHeader_examineMustUnderstandHeaderElements ( Dom d, String mustUnderstandString ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPHeader sh = (SOAPHeader) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapHeader_examineMustUnderstandHeaderElements( sh, mustUnderstandString ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapHeader_examineMustUnderstandHeaderElements( sh, mustUnderstandString ); } finally { l.exit(); } } |
| } |
| |
| public static Iterator soapHeader_extractHeaderElements ( Dom d, String actor ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPHeader sh = (SOAPHeader) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapHeader_extractHeaderElements( sh, actor ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapHeader_extractHeaderElements( sh, actor ); } finally { l.exit(); } } |
| } |
| |
| public static SOAPHeaderElement soapHeader_addHeaderElement ( Dom d, Name name ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPHeader sh = (SOAPHeader) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapHeader_addHeaderElement( sh, name ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapHeader_addHeaderElement( sh, name ); } finally { l.exit(); } } |
| } |
| |
| // |
| // Soap Body |
| // |
| |
| public static boolean soapBody_hasFault ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPBody sb = (SOAPBody) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapBody_hasFault( sb ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapBody_hasFault( sb ); } finally { l.exit(); } } |
| } |
| |
| public static SOAPFault soapBody_addFault ( Dom d ) throws SOAPException |
| { |
| Locale l = d.locale(); |
| |
| SOAPBody sb = (SOAPBody) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapBody_addFault( sb ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapBody_addFault( sb ); } finally { l.exit(); } } |
| } |
| |
| public static SOAPFault soapBody_getFault ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPBody sb = (SOAPBody) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapBody_getFault( sb ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapBody_getFault( sb ); } finally { l.exit(); } } |
| } |
| |
| public static SOAPBodyElement soapBody_addBodyElement ( Dom d, Name name ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPBody sb = (SOAPBody) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapBody_addBodyElement( sb, name ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapBody_addBodyElement( sb, name ); } finally { l.exit(); } } |
| } |
| |
| public static SOAPBodyElement soapBody_addDocument ( Dom d, Document document ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPBody sb = (SOAPBody) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapBody_addDocument( sb, document ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapBody_addDocument( sb, document ); } finally { l.exit(); } } |
| } |
| |
| public static SOAPFault soapBody_addFault ( Dom d, Name name, String s ) throws SOAPException |
| { |
| Locale l = d.locale(); |
| |
| SOAPBody sb = (SOAPBody) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapBody_addFault( sb, name, s ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapBody_addFault( sb, name, s ); } finally { l.exit(); } } |
| } |
| |
| public static SOAPFault soapBody_addFault ( Dom d, Name faultCode, String faultString, java.util.Locale locale ) throws SOAPException |
| { |
| Locale l = d.locale(); |
| |
| SOAPBody sb = (SOAPBody) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapBody_addFault( sb, faultCode, faultString, locale ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapBody_addFault( sb, faultCode, faultString, locale ); } finally { l.exit(); } } |
| } |
| |
| // |
| // Soap Fault |
| // |
| |
| public static void soapFault_setFaultString ( Dom d, String faultString ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPFault sf = (SOAPFault) d; |
| |
| if (l.noSync()) { l.enter(); try { l._saaj.soapFault_setFaultString( sf, faultString ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { l._saaj.soapFault_setFaultString( sf, faultString ); } finally { l.exit(); } } |
| } |
| |
| public static void soapFault_setFaultString ( Dom d, String faultString, java.util.Locale locale ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPFault sf = (SOAPFault) d; |
| |
| if (l.noSync()) { l.enter(); try { l._saaj.soapFault_setFaultString( sf, faultString, locale ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { l._saaj.soapFault_setFaultString( sf, faultString, locale ); } finally { l.exit(); } } |
| } |
| |
| public static void soapFault_setFaultCode ( Dom d, Name faultCodeName ) throws SOAPException |
| { |
| Locale l = d.locale(); |
| |
| SOAPFault sf = (SOAPFault) d; |
| |
| if (l.noSync()) { l.enter(); try { l._saaj.soapFault_setFaultCode( sf, faultCodeName ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { l._saaj.soapFault_setFaultCode( sf, faultCodeName ); } finally { l.exit(); } } |
| } |
| |
| public static void soapFault_setFaultActor ( Dom d, String faultActorString ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPFault sf = (SOAPFault) d; |
| |
| if (l.noSync()) { l.enter(); try { l._saaj.soapFault_setFaultActor( sf, faultActorString ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { l._saaj.soapFault_setFaultActor( sf, faultActorString ); } finally { l.exit(); } } |
| } |
| |
| public static String soapFault_getFaultActor ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPFault sf = (SOAPFault) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapFault_getFaultActor( sf ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapFault_getFaultActor( sf ); } finally { l.exit(); } } |
| } |
| |
| public static String soapFault_getFaultCode ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPFault sf = (SOAPFault) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapFault_getFaultCode( sf ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapFault_getFaultCode( sf ); } finally { l.exit(); } } |
| } |
| |
| public static void soapFault_setFaultCode ( Dom d, String faultCode ) throws SOAPException |
| { |
| Locale l = d.locale(); |
| |
| SOAPFault sf = (SOAPFault) d; |
| |
| if (l.noSync()) { l.enter(); try { l._saaj.soapFault_setFaultCode( sf, faultCode ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { l._saaj.soapFault_setFaultCode( sf, faultCode ); } finally { l.exit(); } } |
| } |
| |
| public static java.util.Locale soapFault_getFaultStringLocale ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPFault sf = (SOAPFault) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapFault_getFaultStringLocale( sf ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapFault_getFaultStringLocale( sf ); } finally { l.exit(); } } |
| } |
| |
| public static Name soapFault_getFaultCodeAsName ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPFault sf = (SOAPFault) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapFault_getFaultCodeAsName( sf ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapFault_getFaultCodeAsName( sf ); } finally { l.exit(); } } |
| } |
| |
| public static String soapFault_getFaultString ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPFault sf = (SOAPFault) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapFault_getFaultString( sf ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapFault_getFaultString( sf ); } finally { l.exit(); } } |
| } |
| |
| public static Detail soapFault_addDetail ( Dom d ) throws SOAPException |
| { |
| Locale l = d.locale(); |
| |
| SOAPFault sf = (SOAPFault) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapFault_addDetail( sf ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapFault_addDetail( sf ); } finally { l.exit(); } } |
| } |
| |
| public static Detail soapFault_getDetail ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPFault sf = (SOAPFault) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapFault_getDetail( sf ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapFault_getDetail( sf ); } finally { l.exit(); } } |
| } |
| |
| // |
| // Soap Header Element |
| // |
| |
| public static void soapHeaderElement_setMustUnderstand ( Dom d, boolean mustUnderstand ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPHeaderElement she = (SOAPHeaderElement) d; |
| |
| if (l.noSync()) { l.enter(); try { l._saaj.soapHeaderElement_setMustUnderstand( she, mustUnderstand ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { l._saaj.soapHeaderElement_setMustUnderstand( she, mustUnderstand ); } finally { l.exit(); } } |
| } |
| |
| public static boolean soapHeaderElement_getMustUnderstand ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPHeaderElement she = (SOAPHeaderElement) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapHeaderElement_getMustUnderstand( she ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapHeaderElement_getMustUnderstand( she ); } finally { l.exit(); } } |
| } |
| |
| public static void soapHeaderElement_setActor ( Dom d, String actor ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPHeaderElement she = (SOAPHeaderElement) d; |
| |
| if (l.noSync()) { l.enter(); try { l._saaj.soapHeaderElement_setActor( she, actor ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { l._saaj.soapHeaderElement_setActor( she, actor ); } finally { l.exit(); } } |
| } |
| |
| public static String soapHeaderElement_getActor ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPHeaderElement she = (SOAPHeaderElement) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapHeaderElement_getActor( she ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapHeaderElement_getActor( she ); } finally { l.exit(); } } |
| } |
| |
| // |
| // Soap Header Element |
| // |
| |
| public static DetailEntry detail_addDetailEntry ( Dom d, Name name ) |
| { |
| Locale l = d.locale(); |
| |
| Detail detail = (Detail) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.detail_addDetailEntry( detail, name ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.detail_addDetailEntry( detail, name ); } finally { l.exit(); } } |
| } |
| |
| public static Iterator detail_getDetailEntries ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| Detail detail = (Detail) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.detail_getDetailEntries( detail ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.detail_getDetailEntries( detail ); } finally { l.exit(); } } |
| } |
| |
| // |
| // Soap Header Element |
| // |
| |
| public static void _soapPart_removeAllMimeHeaders ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPPart sp = (SOAPPart) d; |
| |
| if (l.noSync()) { l.enter(); try { l._saaj.soapPart_removeAllMimeHeaders( sp ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { l._saaj.soapPart_removeAllMimeHeaders( sp ); } finally { l.exit(); } } |
| } |
| |
| public static void _soapPart_removeMimeHeader ( Dom d, String name ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPPart sp = (SOAPPart) d; |
| |
| if (l.noSync()) { l.enter(); try { l._saaj.soapPart_removeMimeHeader( sp, name ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { l._saaj.soapPart_removeMimeHeader( sp, name ); } finally { l.exit(); } } |
| } |
| |
| public static Iterator _soapPart_getAllMimeHeaders ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPPart sp = (SOAPPart) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapPart_getAllMimeHeaders( sp ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapPart_getAllMimeHeaders( sp ); } finally { l.exit(); } } |
| } |
| |
| public static SOAPEnvelope _soapPart_getEnvelope ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPPart sp = (SOAPPart) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapPart_getEnvelope( sp ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapPart_getEnvelope( sp ); } finally { l.exit(); } } |
| } |
| |
| public static Source _soapPart_getContent ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPPart sp = (SOAPPart) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapPart_getContent( sp ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapPart_getContent( sp ); } finally { l.exit(); } } |
| } |
| |
| public static void _soapPart_setContent ( Dom d, Source source ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPPart sp = (SOAPPart) d; |
| |
| if (l.noSync()) { l.enter(); try { l._saaj.soapPart_setContent( sp, source ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { l._saaj.soapPart_setContent( sp, source ); } finally { l.exit(); } } |
| } |
| |
| public static String[] _soapPart_getMimeHeader ( Dom d, String name ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPPart sp = (SOAPPart) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapPart_getMimeHeader( sp, name ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapPart_getMimeHeader( sp, name ); } finally { l.exit(); } } |
| } |
| |
| public static void _soapPart_addMimeHeader ( Dom d, String name, String value ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPPart sp = (SOAPPart) d; |
| |
| if (l.noSync()) { l.enter(); try { l._saaj.soapPart_addMimeHeader( sp, name, value ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { l._saaj.soapPart_addMimeHeader( sp, name, value ); } finally { l.exit(); } } |
| } |
| |
| public static void _soapPart_setMimeHeader ( Dom d, String name, String value ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPPart sp = (SOAPPart) d; |
| |
| if (l.noSync()) { l.enter(); try { l._saaj.soapPart_setMimeHeader( sp, name, value ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { l._saaj.soapPart_setMimeHeader( sp, name, value ); } finally { l.exit(); } } |
| } |
| |
| public static Iterator _soapPart_getMatchingMimeHeaders ( Dom d, String[] names ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPPart sp = (SOAPPart) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapPart_getMatchingMimeHeaders( sp, names ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapPart_getMatchingMimeHeaders( sp, names ); } finally { l.exit(); } } |
| } |
| |
| public static Iterator _soapPart_getNonMatchingMimeHeaders ( Dom d, String[] names ) |
| { |
| Locale l = d.locale(); |
| |
| SOAPPart sp = (SOAPPart) d; |
| |
| if (l.noSync()) { l.enter(); try { return l._saaj.soapPart_getNonMatchingMimeHeaders( sp, names ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return l._saaj.soapPart_getNonMatchingMimeHeaders( sp, names ); } finally { l.exit(); } } |
| } |
| |
| // |
| // Saaj callback |
| // |
| |
| private static class SaajData |
| { |
| Object _obj; |
| } |
| |
| public static void saajCallback_setSaajData ( Dom d, Object o ) |
| { |
| Locale l = d.locale(); |
| |
| if (l.noSync()) { l.enter(); try { impl_saajCallback_setSaajData( d, o ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { impl_saajCallback_setSaajData( d, o ); } finally { l.exit(); } } |
| } |
| |
| public static void impl_saajCallback_setSaajData ( Dom d, Object o ) |
| { |
| Locale l = d.locale(); |
| |
| Cur c = l.tempCur(); |
| |
| c.moveToDom( d ); |
| |
| SaajData sd = null; |
| |
| if (o != null) |
| { |
| sd = (SaajData) c.getBookmark( SaajData.class ); |
| |
| if (sd == null) |
| sd = new SaajData(); |
| |
| sd._obj = o; |
| } |
| |
| c.setBookmark( SaajData.class, sd ); |
| |
| c.release(); |
| } |
| |
| public static Object saajCallback_getSaajData ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| if (l.noSync()) { l.enter(); try { return impl_saajCallback_getSaajData( d ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return impl_saajCallback_getSaajData( d ); } finally { l.exit(); } } |
| } |
| |
| public static Object impl_saajCallback_getSaajData ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| Cur c = l.tempCur(); |
| |
| c.moveToDom( d ); |
| |
| SaajData sd = (SaajData) c.getBookmark( SaajData.class ); |
| |
| Object o = sd == null ? null : sd._obj; |
| |
| c.release(); |
| |
| return o; |
| } |
| |
| public static Element saajCallback_createSoapElement ( Dom d, QName name, QName parentName ) |
| { |
| Locale l = d.locale(); |
| |
| Dom e; |
| |
| if (l.noSync()) { l.enter(); try { e = impl_saajCallback_createSoapElement( d, name, parentName ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { e = impl_saajCallback_createSoapElement( d, name, parentName ); } finally { l.exit(); } } |
| |
| return (Element) e; |
| } |
| |
| public static Dom impl_saajCallback_createSoapElement ( Dom d, QName name, QName parentName ) |
| { |
| Cur c = d.locale().tempCur(); |
| |
| c.createElement( name, parentName ); |
| |
| Dom e = c.getDom(); |
| |
| c.release(); |
| |
| return e; |
| } |
| |
| public static Element saajCallback_importSoapElement ( |
| Dom d, Element elem, boolean deep, QName parentName ) |
| { |
| Locale l = d.locale(); |
| |
| Dom e; |
| |
| if (l.noSync()) { l.enter(); try { e = impl_saajCallback_importSoapElement( d, elem, deep, parentName ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { e = impl_saajCallback_importSoapElement( d, elem, deep, parentName ); } finally { l.exit(); } } |
| |
| return (Element) e; |
| } |
| |
| public static Dom impl_saajCallback_importSoapElement ( |
| Dom d, Element elem, boolean deep, QName parentName ) |
| { |
| // TODO -- need to rewrite DomImpl.document_importNode to use an Xcur |
| // to create the new tree. Then, I can pass the parentName to the new |
| // fcn and use it to create the correct root parent |
| |
| throw new RuntimeException( "Not impl" ); |
| } |
| |
| |
| public static Text saajCallback_ensureSoapTextNode ( Dom d ) |
| { |
| Locale l = d.locale(); |
| |
| if (l.noSync()) { l.enter(); try { return impl_saajCallback_ensureSoapTextNode( d ); } finally { l.exit(); } } |
| else synchronized ( l ) { l.enter(); try { return impl_saajCallback_ensureSoapTextNode( d ); } finally { l.exit(); } } |
| } |
| |
| public static Text impl_saajCallback_ensureSoapTextNode ( Dom d ) |
| { |
| // if (!(d instanceof Text)) |
| // { |
| // Xcur x = d.tempCur(); |
| // |
| // x.moveTo |
| // |
| // x.release(); |
| // } |
| // |
| // return (Text) d; |
| |
| return null; |
| } |
| |
| } |
| |