Google Git
Sign in
apache / xmlbeans / 929cb3ba2afd101bb5adc7e26062ecce17247763 / . / src / store / org / apache / xmlbeans / impl / store / DomImpl.java
blob: 810266747ac17701d4d9bece071bddb9e304b31d [file] [log] [blame]
/* 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.store;
import org.apache.xmlbeans.XmlCursor;
import org.apache.xmlbeans.XmlException;
import org.apache.xmlbeans.XmlObject;
import org.apache.xmlbeans.XmlRuntimeException;
import org.apache.xmlbeans.impl.common.XMLChar;
import org.apache.xmlbeans.impl.soap.*;
import org.w3c.dom.Node;
import org.w3c.dom.Text;
import org.w3c.dom.*;
import javax.xml.namespace.QName;
import javax.xml.stream.XMLStreamReader;
import javax.xml.transform.Source;
import java.io.PrintStream;
import java.util.*;
// DOM Level 3
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 ( );
boolean nodeCanHavePrefixUri( );
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 ); }
static Dom prevSibling ( Dom d ) { return node_getPreviousSibling( 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 ( (parent = parent( parent )) != 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( "Name is null" );
if (name.length() == 0)
throw new IllegalArgumentException( "Name is empty" );
if (!XMLChar.isValidName( name ))
throw new InvalidCharacterError( "Name 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, String uri, boolean isAttr )
{
assert name != null;
if (uri == null)
uri = "";
int i = name.indexOf( ':' );
String local;
if (i < 0)
{
validateNcName( local = name );
if (isAttr && local.equals( "xmlns" ) && !uri.equals( Locale._xmlnsUri ))
{
throw
new NamespaceErr(
"Default xmlns attribute does not have namespace: " + Locale._xmlnsUri );
}
}
else
{
if (i == 0)
throw new NamespaceErr( "Invalid qualified name, no prefix specified" );
String prefix = name.substring( 0, i );
validateNcName( prefix );
if (uri.length() == 0)
throw new NamespaceErr( "Attempt to give a prefix for no namespace" );
local = name.substring( i + 1 );
if (local.indexOf( ':' ) >= 0)
throw new NamespaceErr( "Invalid qualified name, more than one colon" );
validateNcName( local );
if (prefix.equals( "xml" ) && !uri.equals( Locale._xml1998Uri ))
throw new NamespaceErr( "Invalid prefix - begins with 'xml'" );
}
if (local.length() == 0)
throw new NamespaceErr( "Invalid qualified name, no local part specified" );
}
private static void removeNode ( Dom n )
{
assert n.nodeType() != TEXT && n.nodeType() != CDATA;
Cur cFrom = n.tempCur();
cFrom.toEnd();
// Move any char nodes which ater after the node to remove to be before it. The call to
// Next here does two things, it tells me if I can get after the move to remove (all nodes
// but the root) and it positions me at the place where there are char nodes after.
if (cFrom.next())
{
CharNode fromNodes = cFrom.getCharNodes();
if (fromNodes != null)
{
cFrom.setCharNodes( null );
Cur cTo = n.tempCur();
cTo.setCharNodes( CharNode.appendNodes( cTo.getCharNodes(), fromNodes ) );
cTo.release();
}
}
cFrom.release();
Cur.moveNode( (Xobj) n, null );
}
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 { return domImplementation_createDocument( l, u, n, t ); } finally { l.exit(); } }
else synchronized ( l ) { l.enter(); try { return domImplementation_createDocument( l, u, n, t ); } finally { l.exit(); } }
}
public static Document domImplementation_createDocument (
Locale l, String namespaceURI, String qualifiedName, DocumentType doctype )
{
validateQualifiedName( qualifiedName, namespaceURI, false );
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.toParent();
try
{
Locale.autoTypeDocument( c, null, null );
}
catch (XmlException e )
{
throw new XmlRuntimeException( e );
}
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 )
{
validateName( name );
Locale l = d.locale();
Cur c = l.tempCur();
c.createElement( l.makeQualifiedQName( "", name ) );
Dom e = c.getDom();
c.release();
((ElementXobj)e)._canHavePrefixUri = false;
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, uri, false );
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 )
{
validateName( name );
Locale l = d.locale();
Cur c = l.tempCur();
c.createAttr( l.makeQualifiedQName( "", name ) );
Dom e = c.getDom();
c.release();
((AttrXobj)e)._canHavePrefixUri = false;
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, uri, true );
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.insertString( data );
}
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 )
{
if (target == null)
throw new IllegalArgumentException( "Target is null" );
if (target.length() == 0)
throw new IllegalArgumentException( "Target is empty" );
if (!XMLChar.isValidName( target ))
throw new InvalidCharacterError( "Target has an invalid character" );
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.insertString( data );
}
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.setChars( data, 0, 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.setChars( data, 0, 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();
if (l.noSync()) { l.enter(); try { return document_getElementsByTagName( d, name ); } finally { l.exit(); } }
else synchronized ( l ) { l.enter(); try { return document_getElementsByTagName( d, name ); } finally { l.exit(); } }
}
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();
if (l.noSync()) { l.enter(); try { return document_getElementsByTagNameNS( d, uri, local ); } finally { l.exit(); } }
else synchronized ( l ) { l.enter(); try { return document_getElementsByTagNameNS( d, uri, local ); } finally { l.exit(); } }
}
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
{
String prefix = n.getPrefix();
String name = prefix == null || prefix.length() == 0 ? local : prefix + ":" + local;
String uri = n.getNamespaceURI();
if (uri == null || uri.length() == 0)
i = document_createElement( d, name );
else
i = document_createElementNS( d, uri, name );
}
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
{
String prefix = n.getPrefix();
String name = prefix == null || prefix.length() == 0 ? local : prefix + ":" + local;
String uri = n.getNamespaceURI();
if (uri == null || uri.length() == 0)
i = document_createAttribute( d, name );
else
i = document_createAttributeNS( d, uri, name );
}
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 d )
{
Locale l = d.locale();
Dom dt;
if (l.noSync()) { l.enter(); try { dt = document_getDoctype( d ); } finally { l.exit(); } }
else synchronized ( l ) { l.enter(); try { dt = document_getDoctype( d ); } finally { l.exit(); } }
return (DocumentType) dt;
}
public static Dom document_getDoctype ( Dom d )
{
return null;
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
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;
assert n instanceof Xobj;
Xobj node = (Xobj)n;
if (!node.isVacant())
{
if (node.isFirstChildPtrDomUsable())
return (Node) node._firstChild;
Xobj lastAttr = node.lastAttr();
if (lastAttr != null &&
lastAttr.isNextSiblingPtrDomUsable())
return (NodeXobj) lastAttr._nextSibling;
if (node.isExistingCharNodesValueUsable())
return node._charNodesValue;
}
if (l.noSync()) { fc = node_getFirstChild( n ); }
else synchronized ( l ) { fc = node_getFirstChild( n ); }
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 :
{
Xobj node = (Xobj) n;
node.ensureOccupancy();
if (node.isFirstChildPtrDomUsable())
return (NodeXobj) node._firstChild;
Xobj lastAttr = node.lastAttr();
if (lastAttr != null)
{
if (lastAttr.isNextSiblingPtrDomUsable())
return (NodeXobj) lastAttr._nextSibling;
else if (lastAttr.isCharNodesAfterUsable())
return (CharNode) lastAttr._charNodesAfter;
}
if (node.isCharNodesValueUsable())
return node._charNodesValue;
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()) { ns = node_getNextSibling( n ); }
else synchronized ( l ) { ns = node_getNextSibling( n ); }
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;
//if src is attr & next is null , ret null;
//if src is container and
// a) this node is aftertext && src._nextSib = null; ret null
// b) this node is value && src._fc = null; ret null
if (! (cn.getObject() instanceof Xobj) )
return null;
Xobj src = (Xobj) cn.getObject();
//if src is attr this node is always value and
// next is always the next ptr of the attr
src._charNodesAfter =
Cur.updateCharNodes( src._locale, src, src._charNodesAfter, src._cchAfter );
src._charNodesValue =
Cur.updateCharNodes( src._locale, src, src._charNodesValue, src._cchValue );
if (cn._next != null)
{
ns = cn._next;
break;
}
boolean isThisNodeAfterText = cn.isNodeAftertext();
if (isThisNodeAfterText)
ns = (NodeXobj) src._nextSibling;
else //srcValue or attribute source
ns = (NodeXobj) src._firstChild;
break;
}
case PROCINST :
case COMMENT :
case ELEMENT :
{
assert n instanceof Xobj: "PI, Comments and Elements always backed up by Xobj";
Xobj node = (Xobj) n;
node.ensureOccupancy();
if (node.isNextSiblingPtrDomUsable())
return
(NodeXobj) node._nextSibling;
if (node.isCharNodesAfterUsable())
return node._charNodesAfter;
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()) { ps = node_getPreviousSibling( n ); }
else synchronized ( l ) { ps = node_getPreviousSibling( n ); }
return (Node) ps;
}
public static Dom node_getPreviousSibling ( Dom n )
{
Dom prev;
switch (n.nodeType()) {
case TEXT:
case CDATA: {
assert n instanceof CharNode: "Text/CData should be a CharNode";
CharNode node = (CharNode) n;
if (!(node.getObject() instanceof Xobj))
return null;
Xobj src = (Xobj) node.getObject();
src.ensureOccupancy();
boolean isThisNodeAfterText = node.isNodeAftertext();
prev = node._prev;
if (prev == null)
prev = isThisNodeAfterText ? (Dom) src :
src._charNodesValue;
break;
}
default: {
assert n instanceof Xobj;
Xobj node = (Xobj) n;
prev = (Dom) node._prevSibling;
if ((prev == null || !(node instanceof AttrXobj) && prev instanceof AttrXobj) &&
node._parent != null) {
prev = node_getFirstChild((Dom) node._parent);
}
}
}
Dom temp = prev;
while (temp != null && (temp = node_getNextSibling(temp)) != n) {
prev = temp;
}
return prev;
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
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();
hasAttrs = c.hasAttrs();
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();
do
{
c.nextWithAttrs();
CharNode cn = c.getCharNodes();
if (cn != null)
{
if (!c.isText())
{
while ( cn != null )
{
cn.setChars( null, 0, 0 );
cn = CharNode.remove( cn, cn );
}
}
else if (cn._next != null)
{
while ( cn._next != null )
{
cn.setChars( null, 0, 0 );
cn = CharNode.remove( cn, cn._next );
}
cn._cch = Integer.MAX_VALUE;
}
c.setCharNodes( cn );
}
}
while ( ! c.isAtEndOfLastPush() );
c.release();
n.locale().invalidateDomCaches(n);
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
public static boolean _node_hasChildNodes ( Dom n ) {
// TODO - make this faster
return n instanceof Xobj && _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;
// Inserting self before self is a no-op
if (nc == rc)
return nc;
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.moveNode( (Xobj) nc, cTo );
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 cTo = rc.tempCur();
Cur.moveNode( (Xobj) nc, cTo );
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.getObject(), 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.getDom() != null);
cn.setChars( c.moveChars( null, cn._cch ), c._offSrc, 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.setChars( c.getChars( ((CharNode) n)._cch ), c._offSrc, 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 )
{
if (! n.nodeCanHavePrefixUri() ) return null;
QName name = n.getQName();
return name == null ? "" : name.getLocalPart();
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
public static String _node_getNamespaceURI ( Dom n )
{
if (! n.nodeCanHavePrefixUri() ) return null;
QName name = n.getQName();
// TODO - should return the correct namespace for xmlns ...
return name == null ? "":
//name.getNamespaceURI().equals("")? 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 )
{
if (! n.nodeCanHavePrefixUri() ) return null;
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 );
cn._cch = nodeValue.length();
c.insertString( nodeValue );
c.release();
}
else
cn.setChars( nodeValue, 0, 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.setChars( nodeValue, 0, nodeValue.length() );
node_insertBefore( n, tn, null );
}
else
{
assert children.getLength() == 1;
children.item( 0 ).setNodeValue( nodeValue );
}
if (((AttrXobj) n).isId())
{
Dom d = DomImpl.node_getOwnerDocument(n);
String val = node_getNodeValue(n);
if (d instanceof DocumentXobj)
{
((DocumentXobj) d).removeIdElement(val);
((DocumentXobj) d).addIdElement(nodeValue,
attr_getOwnerElement(n));
}
}
break;
}
case PROCINST :
case COMMENT :
{
Cur c = n.tempCur();
c.next();
c.getChars( -1 );
c.moveChars( null, c._cchSrc );
c.insertString( nodeValue );
c.release();
break;
}
}
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
public static String _node_getNodeValue ( Dom n )
{
Locale l = n.locale();
if (l.noSync()) { return node_getNodeValue( n ); }
else synchronized ( l ) { return node_getNodeValue( n ); }
}
public static String node_getNodeValue ( Dom n )
{
String s = null;
switch ( n.nodeType() )
{
case ATTR :
case PROCINST :
case COMMENT :
{
s = ((Xobj)n).getValueAsString();
break;
}
case TEXT :
case CDATA :
{
assert n instanceof CharNode: "Text/CData should be a CharNode";
CharNode node = (CharNode) n;
if (! (node.getObject() instanceof Xobj) ) {
s = CharUtil.getString(node.getObject(), node._off, node._cch);
}else{
Xobj src = (Xobj) node.getObject();
src.ensureOccupancy();
boolean isThisNodeAfterText = node.isNodeAftertext();
if( isThisNodeAfterText ){
src._charNodesAfter =
Cur.updateCharNodes( src._locale, src, src._charNodesAfter, src._cchAfter );
s = src.getCharsAfterAsString(node._off, node._cch);
}
else{
src._charNodesValue =
Cur.updateCharNodes( src._locale, src, src._charNodesValue, src._cchValue );
s = src.getCharsValueAsString(node._off, node._cch);
}
}
break;
}
}
return s;
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
public static Object _node_getUserData ( Dom n, String key ) {
throw new DomLevel3NotImplemented();
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
public static Object _node_setUserData ( Dom n, String key, Object data, UserDataHandler handler ) {
throw new DomLevel3NotImplemented();
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
public static Object _node_getFeature ( Dom n, String feature, String version ) {
throw new DomLevel3NotImplemented();
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
public static boolean _node_isEqualNode ( Dom n, Node arg ) {
throw new DomLevel3NotImplemented();
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
public static boolean _node_isSameNode ( Dom n, Node arg ) {
// TODO: check if relying on object identity is ok
boolean ret;
if (n instanceof CharNode) {
// ret = ((CharNode)n).getDom().equals(arg);
ret = n.equals(arg);
} else if (n instanceof NodeXobj) {
ret = ((NodeXobj)n).getDom().equals(arg);
} else {
throw new DomLevel3NotImplemented();
}
return ret;
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
public static String _node_lookupNamespaceURI ( Dom n, String prefix ) {
throw new DomLevel3NotImplemented();
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
public static boolean _node_isDefaultNamespace ( Dom n, String namespaceURI ) {
throw new DomLevel3NotImplemented();
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
public static String _node_lookupPrefix ( Dom n, String namespaceURI ) {
throw new DomLevel3NotImplemented();
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
public static void _node_setTextContent ( Dom n, String textContent ) {
throw new DomLevel3NotImplemented();
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
public static String _node_getTextContent ( Dom n ) {
throw new DomLevel3NotImplemented();
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
public static short _node_compareDocumentPosition ( Dom n, Node other ) {
// TODO: find a faster way to compare, may be based on the locale / cursor elements inside the nodes
if (!(n instanceof Node)) {
return Node.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC;
}
Iterator<Node> nAncIter = ancestorAndSelf((Node)n).iterator();
Iterator<Node> oAncIter = ancestorAndSelf(other).iterator();
Node nAnc, oAnc;
boolean isFirst = true, isEqual;
do {
nAnc = nAncIter.next();
oAnc = oAncIter.next();
isEqual = Objects.equals(nAnc,oAnc);
if (isFirst && !isEqual) {
// if root node differ, the elements are from different documents
return Node.DOCUMENT_POSITION_DISCONNECTED;
}
isFirst = false;
} while (isEqual && nAncIter.hasNext() && oAncIter.hasNext());
if (isEqual) {
return nAncIter.hasNext()
? Node.DOCUMENT_POSITION_CONTAINS | Node.DOCUMENT_POSITION_PRECEDING
: (oAncIter.hasNext()
? Node.DOCUMENT_POSITION_CONTAINED_BY | Node.DOCUMENT_POSITION_FOLLOWING
: Node.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC
);
} else {
Node prevSib = nAnc;
while ((prevSib = prevSib.getPreviousSibling()) != null) {
if (Objects.equals(prevSib, oAnc)) {
return Node.DOCUMENT_POSITION_PRECEDING;
}
}
return Node.DOCUMENT_POSITION_FOLLOWING;
}
}
private static List<Node> ancestorAndSelf(Node node) {
LinkedList<Node> nodes = new LinkedList<>();
Node n = node;
do {
nodes.addFirst(n);
n = n.getParentNode();
} while (n != null);
return nodes;
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
public static String _node_getBaseURI ( Dom n ) {
throw new DomLevel3NotImplemented();
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
public static Node _childNodes_item ( Dom n, int i )
{
Locale l = n.locale();
Dom d;
if (i == 0) return _node_getFirstChild(n);
if (l.noSync()) { d = childNodes_item( n, i ); }
else synchronized ( l ) { d = childNodes_item( n, i ); }
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;
}
if ( i == 0 )
return node_getFirstChild ( n );
return n.locale().findDomNthChild(n, i);
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
public static int _childNodes_getLength ( Dom n )
{
Locale l = n.locale();
assert n instanceof Xobj;
int count;
Xobj node = (Xobj) n;
if (!node.isVacant() &&
(count = node.getDomZeroOneChildren()) < 2)
return count;
if (l.noSync()) { return childNodes_getLength( n ); }
else synchronized ( l ) { return childNodes_getLength( n ); }
}
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;
}
int count;
assert n instanceof Xobj;
Xobj node = (Xobj) n;
node.ensureOccupancy();
if ((count = node.getDomZeroOneChildren()) < 2)
return count;
return n.locale().domLength(n);
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
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 )
{
validateQualifiedName( qname, uri, true );
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();
if (l.noSync()) { l.enter(); try { return element_getElementsByTagName( e, name ); } finally { l.exit(); } }
else synchronized ( l ) { l.enter(); try { return element_getElementsByTagName( e, name ); } finally { l.exit(); } }
}
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();
if (l.noSync()) { l.enter(); try { return element_getElementsByTagNameNS( e, uri, local ); } finally { l.exit(); } }
else synchronized ( l ) { l.enter(); try { return element_getElementsByTagNameNS( e, uri, local ); } finally { l.exit(); } }
}
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 )
{
int n = 0;
Cur c = e.tempCur();
while ( c.toNextAttr() )
n++;
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();
while ( c.toNextAttr() )
{
Dom aa = c.getDom();
if (_node_getNodeName( aa ).equals( name ))
{
if (oldAttr == null)
oldAttr = aa;
else
{
removeNode( aa );
c.toPrevAttr();
}
}
}
if (oldAttr == null)
{
c.moveToDom( e );
c.next();
Cur.moveNode( (Xobj) a, c );
}
else
{
c.moveToDom( oldAttr );
Cur.moveNode( (Xobj) a, c );
removeNode( oldAttr );
}
c.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();
while ( c.toNextAttr() )
{
Dom d = c.getDom();
if (_node_getNodeName( d ).equals( name ))
{
a = d;
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();
while ( c.toNextAttr() )
{
Dom d = c.getDom();
QName n = d.getQName();
if (n.getNamespaceURI().equals( uri ) && n.getLocalPart().equals( local ))
{
a = d;
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();
while ( c.toNextAttr() )
{
Dom aa = c.getDom();
if (_node_getNodeName(aa).equals(name))
{
if (oldAttr == null)
oldAttr = aa;
if (((AttrXobj) aa).isId())
{
Dom d = DomImpl.node_getOwnerDocument(aa);
String val = node_getNodeValue( aa );
if (d instanceof DocumentXobj)
((DocumentXobj) d).removeIdElement(val);
}
removeNode(aa);
c.toPrevAttr();
}
}
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();
while ( c.toNextAttr() )
{
Dom aa = c.getDom();
QName qn = aa.getQName();
if (qn.getNamespaceURI().equals( uri ) && qn.getLocalPart().equals( local ))
{
if (oldAttr == null)
oldAttr = aa;
if (((AttrXobj) aa).isId())
{
Dom d = DomImpl.node_getOwnerDocument(aa);
String val = node_getNodeValue( aa );
if (d instanceof DocumentXobj)
((DocumentXobj) d).removeIdElement(val);
}
removeNode( aa );
c.toPrevAttr();
}
}
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();
while ( c.toNextAttr() )
{
Dom aa = c.getDom();
if (aa.getQName().equals( name ))
{
if (oldAttr == null)
oldAttr = aa;
else
{
removeNode( aa );
c.toPrevAttr();
}
}
}
if (oldAttr == null)
{
c.moveToDom( e );
c.next();
Cur.moveNode( (Xobj) a, c );
}
else
{
c.moveToDom( oldAttr );
Cur.moveNode( (Xobj) a, c );
removeNode( oldAttr );
}
c.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;
while ( c.toNextAttr() )
{
if (index-- == 0)
{
a = c.getDom();
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())
{
c.release();
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 ) );
t.locale().invalidateDomCaches(p);
}
return (Text) t2;
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
public static String _text_getWholeText ( Dom t ) {
throw new DomLevel3NotImplemented();
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
public static boolean _text_isElementContentWhitespace ( Dom t ) {
throw new DomLevel3NotImplemented();
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
public static Text _text_replaceWholeText ( Dom t, String content ) {
throw new DomLevel3NotImplemented();
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
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.getObject(), 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;
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
public static XmlObject _getXmlObject ( Dom n )
{
Locale l = n.locale();
if (l.noSync()) { l.enter(); try { return getXmlObject( n ); } finally { l.exit(); } }
else synchronized ( l ) { l.enter(); try { return getXmlObject( n ); } finally { l.exit(); } }
}
public static XmlObject getXmlObject ( Dom n )
{
Cur c = n.tempCur();
XmlObject x = c.getObject();
c.release();
return x;
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//
// Soap Text Node
//
public static boolean _soapText_isComment ( Dom n )
{
Locale l = n.locale();
org.apache.xmlbeans.impl.soap.Text text = (org.apache.xmlbeans.impl.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();
org.apache.xmlbeans.impl.soap.Node node = (org.apache.xmlbeans.impl.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();
org.apache.xmlbeans.impl.soap.Node node = (org.apache.xmlbeans.impl.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();
org.apache.xmlbeans.impl.soap.Node node = (org.apache.xmlbeans.impl.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();
org.apache.xmlbeans.impl.soap.Node node = (org.apache.xmlbeans.impl.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();
org.apache.xmlbeans.impl.soap.Node node = (org.apache.xmlbeans.impl.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();
org.apache.xmlbeans.impl.soap.Node node = (org.apache.xmlbeans.impl.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;
}
public static class DomLevel3NotImplemented extends RuntimeException {
DomLevel3NotImplemented() {
super("DOM Level 3 Not implemented");
}
}
}