Save This Page
Home » xmlbeans-2.5.0-src » org.apache.xmlbeans.impl » store » [javadoc | source]
    1   /*   Copyright 2004 The Apache Software Foundation
    2    *
    3    *   Licensed under the Apache License, Version 2.0 (the "License");
    4    *   you may not use this file except in compliance with the License.
    5    *   You may obtain a copy of the License at
    6    *
    7    *       http://www.apache.org/licenses/LICENSE-2.0
    8    *
    9    *   Unless required by applicable law or agreed to in writing, software
   10    *   distributed under the License is distributed on an "AS IS" BASIS,
   11    *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12    *   See the License for the specific language governing permissions and
   13    *  limitations under the License.
   14    */
   15   
   16   package org.apache.xmlbeans.impl.store;
   17   
   18   import org.w3c.dom.Attr;
   19   import org.w3c.dom.CDATASection;
   20   import org.w3c.dom.CharacterData;
   21   import org.w3c.dom.Comment;
   22   import org.w3c.dom.Document;
   23   import org.w3c.dom.DocumentFragment;
   24   import org.w3c.dom.DocumentType;
   25   import org.w3c.dom.DOMException;
   26   import org.w3c.dom.DOMImplementation;
   27   import org.w3c.dom.Element;
   28   import org.w3c.dom.EntityReference;
   29   import org.w3c.dom.NamedNodeMap;
   30   import org.w3c.dom.Node;
   31   import org.w3c.dom.NodeList;
   32   import org.w3c.dom.ProcessingInstruction;
   33   import org.w3c.dom.Text;
   34   import org.w3c.dom.DOMImplementation;
   35   
   36   // DOM Level 3
   37   import org.w3c.dom.UserDataHandler;
   38   
   39   
   40   import org.apache.xmlbeans.impl.common.XMLChar;
   41   import org.apache.xmlbeans.impl.soap.Detail;
   42   import org.apache.xmlbeans.impl.soap.DetailEntry;
   43   import org.apache.xmlbeans.impl.soap.MimeHeaders;
   44   import org.apache.xmlbeans.impl.soap.Name;
   45   import org.apache.xmlbeans.impl.soap.SOAPBody;
   46   import org.apache.xmlbeans.impl.soap.SOAPBodyElement;
   47   import org.apache.xmlbeans.impl.soap.SOAPElement;
   48   import org.apache.xmlbeans.impl.soap.SOAPEnvelope;
   49   import org.apache.xmlbeans.impl.soap.SOAPException;
   50   import org.apache.xmlbeans.impl.soap.SOAPFactory;
   51   import org.apache.xmlbeans.impl.soap.SOAPFault;
   52   import org.apache.xmlbeans.impl.soap.SOAPHeader;
   53   import org.apache.xmlbeans.impl.soap.SOAPHeaderElement;
   54   import org.apache.xmlbeans.impl.soap.SOAPPart;
   55   
   56   import javax.xml.stream.XMLStreamReader;
   57   
   58   import java.io.PrintStream;
   59   
   60   import java.util.ArrayList;
   61   import java.util.Iterator;
   62   
   63   import javax.xml.transform.Source;
   64   import javax.xml.namespace.QName;
   65   
   66   import org.apache.xmlbeans.XmlException;
   67   import org.apache.xmlbeans.XmlRuntimeException;
   68   import org.apache.xmlbeans.XmlCursor;
   69   import org.apache.xmlbeans.XmlObject;
   70   
   71   final class DomImpl
   72   {
   73       static final int ELEMENT   = Node.ELEMENT_NODE;
   74       static final int ATTR      = Node.ATTRIBUTE_NODE;
   75       static final int TEXT      = Node.TEXT_NODE;
   76       static final int CDATA     = Node.CDATA_SECTION_NODE;
   77       static final int ENTITYREF = Node.ENTITY_REFERENCE_NODE;
   78       static final int ENTITY    = Node.ENTITY_NODE;
   79       static final int PROCINST  = Node.PROCESSING_INSTRUCTION_NODE;
   80       static final int COMMENT   = Node.COMMENT_NODE;
   81       static final int DOCUMENT  = Node.DOCUMENT_NODE;
   82       static final int DOCTYPE   = Node.DOCUMENT_TYPE_NODE;
   83       static final int DOCFRAG   = Node.DOCUMENT_FRAGMENT_NODE;
   84       static final int NOTATION  = Node.NOTATION_NODE;
   85   
   86       interface Dom
   87       {
   88           Locale locale   ( );
   89           int    nodeType ( );
   90           Cur    tempCur  ( );
   91           QName  getQName ( );
   92           boolean nodeCanHavePrefixUri( );
   93   
   94           void   dump ( );
   95           void   dump ( PrintStream o );
   96           void   dump ( PrintStream o, Object ref );
   97       };
   98       
   99       static Dom parent      ( Dom d ) { return node_getParentNode ( d ); }
  100       static Dom firstChild  ( Dom d ) { return node_getFirstChild ( d ); }
  101       static Dom nextSibling ( Dom d ) { return node_getNextSibling( d ); }
  102       static Dom prevSibling ( Dom d ) { return node_getPreviousSibling( d ); }
  103   
  104       public static Dom append ( Dom n, Dom p )
  105       {
  106           return node_insertBefore( p, n, null );
  107       }
  108   
  109       public static Dom insert ( Dom n, Dom b )
  110       {
  111           assert b != null;
  112           return node_insertBefore( parent( b ), n, b );
  113       }
  114   
  115       public static Dom remove ( Dom n )
  116       {
  117           Dom p = parent( n );
  118   
  119           if (p != null)
  120               node_removeChild( p, n );
  121   
  122           return n;
  123       }
  124   
  125       //
  126       // Handy dandy Dom exceptions
  127       //
  128   
  129       static class HierarchyRequestErr extends DOMException
  130       {
  131           HierarchyRequestErr ( ) { this( "This node isn't allowed there" ); }
  132           HierarchyRequestErr ( String message ) { super( HIERARCHY_REQUEST_ERR, message ); }
  133       }
  134       
  135       static class WrongDocumentErr extends DOMException
  136       {
  137           WrongDocumentErr ( ) { this( "Nodes do not belong to the same document" ); }
  138           WrongDocumentErr ( String message ) { super( WRONG_DOCUMENT_ERR, message ); }
  139       }
  140       
  141       static class NotFoundErr extends DOMException
  142       {
  143           NotFoundErr ( ) { this( "Node not found" ); }
  144           NotFoundErr ( String message ) { super( NOT_FOUND_ERR, message ); }
  145       }
  146   
  147       static class NamespaceErr extends DOMException
  148       {
  149           NamespaceErr ( ) { this( "Namespace error" ); }
  150           NamespaceErr ( String message ) { super( NAMESPACE_ERR, message ); }
  151       }
  152   
  153       static class NoModificationAllowedErr extends DOMException
  154       {
  155           NoModificationAllowedErr ( ) { this( "No modification allowed error" ); }
  156           NoModificationAllowedErr ( String message ) { super( NO_MODIFICATION_ALLOWED_ERR, message ); }
  157       }
  158       
  159       static class InuseAttributeError extends DOMException
  160       {
  161           InuseAttributeError ( ) { this( "Attribute currently in use error" ); }
  162           InuseAttributeError ( String message ) { super( INUSE_ATTRIBUTE_ERR, message ); }
  163       }
  164       
  165       static class IndexSizeError extends DOMException
  166       {
  167           IndexSizeError ( ) { this( "Index Size Error" ); }
  168           IndexSizeError ( String message ) { super( INDEX_SIZE_ERR, message ); }
  169       }
  170   
  171       static class NotSupportedError extends DOMException
  172       {
  173           NotSupportedError ( ) { this( "This operation is not supported" ); }
  174           NotSupportedError ( String message ) { super( NOT_SUPPORTED_ERR, message ); }
  175       }
  176   
  177       static class InvalidCharacterError extends DOMException
  178       {
  179           InvalidCharacterError ( ) { this( "The name contains an invalid character" ); }
  180           InvalidCharacterError ( String message ) { super( INVALID_CHARACTER_ERR, message ); }
  181       }
  182   
  183       //
  184       // Helper fcns
  185       //
  186       
  187       private static final class EmptyNodeList implements NodeList
  188       {
  189           public int getLength ( ) { return 0; }
  190           public Node item ( int i ) { return null; }
  191       }
  192   
  193       public static NodeList _emptyNodeList = new EmptyNodeList();
  194       
  195       static String nodeKindName ( int t )
  196       {
  197           switch ( t )
  198           {
  199           case ATTR      : return "attribute";
  200           case CDATA     : return "cdata section";
  201           case COMMENT   : return "comment";
  202           case DOCFRAG   : return "document fragment";
  203           case DOCUMENT  : return "document";
  204           case DOCTYPE   : return "document type";
  205           case ELEMENT   : return "element";
  206           case ENTITY    : return "entity";
  207           case ENTITYREF : return "entity reference";
  208           case NOTATION  : return "notation";
  209           case PROCINST  : return "processing instruction";
  210           case TEXT      : return "text";
  211                                              
  212           default : throw new RuntimeException( "Unknown node type" );
  213           }
  214       }
  215   
  216       private static String isValidChild ( Dom parent, Dom child )
  217       {
  218           int pk = parent.nodeType();
  219           int ck = child.nodeType();
  220   
  221           switch ( pk )
  222           {
  223           case DOCUMENT :
  224           {
  225               switch ( ck )
  226               {
  227               case ELEMENT :
  228               {
  229                   if (document_getDocumentElement( parent ) != null)
  230                       return "Documents may only have a maximum of one document element";
  231   
  232                   return null;
  233               }
  234               case DOCTYPE :
  235               {
  236                   if (document_getDoctype( parent ) != null)
  237                       return "Documents may only have a maximum of one document type node";
  238                   
  239                   return null;
  240               }
  241               case PROCINST :
  242               case COMMENT  :
  243                   return null;
  244               }
  245   
  246               break;
  247           }
  248   
  249           case ATTR :
  250           {
  251               if (ck == TEXT || ck == ENTITYREF)
  252                   return null;
  253   
  254               // TODO -- traverse the entity tree, making sure that there are
  255               // only entity refs and text nodes in it.
  256   
  257               break;
  258           }
  259               
  260           case DOCFRAG   :
  261           case ELEMENT   :
  262           case ENTITY    :
  263           case ENTITYREF :
  264           {
  265               switch ( ck )
  266               {
  267               case ELEMENT :
  268               case ENTITYREF:
  269               case CDATA :
  270               case TEXT :
  271               case COMMENT :
  272               case PROCINST :
  273                   return null;
  274               }
  275   
  276               break;
  277           }
  278   
  279           case CDATA :
  280           case TEXT :
  281           case COMMENT :
  282           case PROCINST :
  283           case DOCTYPE :
  284           case NOTATION :
  285               return nodeKindName( pk ) + " nodes may not have any children";
  286           }
  287   
  288           return
  289               nodeKindName( pk ) + " nodes may not have " +
  290                   nodeKindName( ck ) + " nodes as children";
  291       }
  292   
  293       private static void validateNewChild ( Dom parent, Dom child )
  294       {
  295           String msg = isValidChild( parent, child );
  296   
  297           if (msg != null)
  298               throw new HierarchyRequestErr( msg );
  299   
  300           if (parent == child)
  301               throw new HierarchyRequestErr( "New child and parent are the same node" );
  302   
  303           while ( (parent = parent( parent )) != null )
  304           {
  305               // TODO - use read only state on a node to know if it is under an
  306               // entity ref
  307               
  308               if (child.nodeType() == ENTITYREF)
  309                   throw new NoModificationAllowedErr( "Entity reference trees may not be modified" );
  310   
  311               if (child == parent)
  312                   throw new HierarchyRequestErr( "New child is an ancestor node of the parent node" );
  313           }
  314       }
  315   
  316       private static String validatePrefix (
  317           String prefix, String uri, String local, boolean isAttr )
  318       {
  319           validateNcName( prefix );
  320           
  321           if (prefix == null)
  322               prefix = "";
  323   
  324           if (uri == null)
  325               uri = "";
  326   
  327           if (prefix.length() > 0 && uri.length() == 0)
  328               throw new NamespaceErr( "Attempt to give a prefix for no namespace" );
  329   
  330           if (prefix.equals( "xml" ) && !uri.equals( Locale._xml1998Uri ))
  331               throw new NamespaceErr( "Invalid prefix - begins with 'xml'" );
  332   
  333           if (isAttr)
  334           {
  335               if (prefix.length() > 0)
  336               {
  337                   if (local.equals( "xmlns" ))
  338                       throw new NamespaceErr( "Invalid namespace - attr is default namespace already" );
  339   
  340                   if (Locale.beginsWithXml( local ))
  341                       throw new NamespaceErr( "Invalid namespace - attr prefix begins with 'xml'" );
  342   
  343                   if (prefix.equals( "xmlns" ) && !uri.equals( Locale._xmlnsUri ))
  344                       throw new NamespaceErr( "Invalid namespace - uri is not '" + Locale._xmlnsUri+";" );
  345               }
  346               else
  347               {
  348                   if (local.equals( "xmlns" ) && !uri.equals( Locale._xmlnsUri ))
  349                       throw new NamespaceErr( "Invalid namespace - uri is not '" + Locale._xmlnsUri+";" );
  350               }
  351           }
  352           else if (Locale.beginsWithXml( prefix ))
  353               throw new NamespaceErr( "Invalid prefix - begins with 'xml'" );
  354   
  355           return prefix;
  356       }
  357       
  358       private static void validateName ( String name )
  359       {
  360           if (name == null)
  361               throw new IllegalArgumentException( "Name is null" );
  362               
  363           if (name.length() == 0)
  364               throw new IllegalArgumentException( "Name is empty" );
  365               
  366           if (!XMLChar.isValidName( name ))
  367               throw new InvalidCharacterError( "Name has an invalid character" );
  368       }
  369        
  370       private static void validateNcName ( String name )
  371       {
  372           if (name != null && name.length() > 0 && !XMLChar.isValidNCName( name ))
  373               throw new InvalidCharacterError();
  374       }
  375       
  376       private static void validateQualifiedName ( String name, String uri, boolean isAttr )
  377       {
  378           assert name != null;
  379   
  380           if (uri == null)
  381               uri = "";
  382           
  383           int i = name.indexOf( ':' );
  384   
  385           String local;
  386           
  387           if (i < 0)
  388           {
  389               validateNcName( local = name );
  390   
  391               if (isAttr && local.equals( "xmlns" ) && !uri.equals( Locale._xmlnsUri ))
  392               {
  393                   throw
  394                       new NamespaceErr(
  395                           "Default xmlns attribute does not have namespace: " + Locale._xmlnsUri );
  396               }
  397           }
  398           else
  399           {
  400               if (i == 0)
  401                   throw new NamespaceErr( "Invalid qualified name, no prefix specified" );
  402   
  403               String prefix = name.substring( 0, i );
  404               
  405               validateNcName( prefix );
  406   
  407               if (uri.length() == 0)
  408                   throw new NamespaceErr( "Attempt to give a prefix for no namespace" );
  409               
  410               local = name.substring( i + 1 );
  411               
  412               if (local.indexOf( ':' ) >= 0)
  413                   throw new NamespaceErr( "Invalid qualified name, more than one colon" );
  414               
  415               validateNcName( local );
  416   
  417               if (prefix.equals( "xml" ) && !uri.equals( Locale._xml1998Uri ))
  418                   throw new NamespaceErr( "Invalid prefix - begins with 'xml'" );
  419           }
  420           
  421           if (local.length() == 0)
  422               throw new NamespaceErr( "Invalid qualified name, no local part specified" );
  423       }
  424   
  425       private static void removeNode ( Dom n )
  426       {
  427           assert n.nodeType() != TEXT && n.nodeType() != CDATA;
  428           
  429           Cur cFrom = n.tempCur();
  430   
  431           cFrom.toEnd();
  432   
  433           // Move any char nodes which ater after the node to remove to be before it.  The call to
  434           // Next here does two things, it tells me if I can get after the move to remove (all nodes
  435           // but the root) and it positions me at the place where there are char nodes after.
  436           
  437           if (cFrom.next())
  438           {
  439               CharNode fromNodes = cFrom.getCharNodes();
  440   
  441               if (fromNodes != null)
  442               {
  443                   cFrom.setCharNodes( null );
  444                   Cur cTo = n.tempCur();
  445                   cTo.setCharNodes( CharNode.appendNodes( cTo.getCharNodes(), fromNodes ) );
  446                   cTo.release();
  447               }
  448           }
  449   
  450           cFrom.release();
  451   
  452           Cur.moveNode( (Xobj) n, null );
  453       }
  454   
  455       private abstract static class ElementsNodeList implements NodeList
  456       {
  457           ElementsNodeList ( Dom root )
  458           {
  459               assert root.nodeType() == DOCUMENT || root.nodeType() == ELEMENT;
  460   
  461               _root = root;
  462               _locale = _root.locale();
  463               _version = 0;
  464           }
  465   
  466           public int getLength ( )
  467           {
  468               ensureElements();
  469   
  470               return _elements.size();
  471           }
  472           
  473           public Node item ( int i )
  474           {
  475               ensureElements();
  476   
  477               return i < 0 || i >= _elements.size() ? (Node) null : (Node) _elements.get( i );
  478           }
  479           
  480           private void ensureElements ( )
  481           {
  482               if (_version == _locale.version())
  483                   return;
  484   
  485               _version = _locale.version();
  486   
  487               _elements = new ArrayList();
  488   
  489               Locale l = _locale;
  490   
  491               if (l.noSync())         { l.enter(); try { addElements( _root ); } finally { l.exit(); } }
  492               else synchronized ( l ) { l.enter(); try { addElements( _root ); } finally { l.exit(); } }
  493           }
  494   
  495           private void addElements ( Dom node )
  496           {
  497               for ( Dom c = firstChild( node ) ; c != null ; c = nextSibling( c ) )
  498               {
  499                   if (c.nodeType() == ELEMENT)
  500                   {
  501                       if (match( c ))
  502                           _elements.add( c );
  503   
  504                       addElements( c );
  505                   }
  506               }
  507           }
  508   
  509           protected abstract boolean match ( Dom element );
  510   
  511           private Dom       _root;
  512           private Locale    _locale;
  513           private long      _version;
  514           private ArrayList _elements;
  515       }
  516   
  517       private static class ElementsByTagNameNodeList extends ElementsNodeList
  518       {
  519           ElementsByTagNameNodeList ( Dom root, String name )
  520           {
  521               super( root );
  522   
  523               _name = name;
  524           }
  525   
  526           protected boolean match ( Dom element )
  527           {
  528               return _name.equals( "*" ) ? true : _node_getNodeName( element ).equals( _name );
  529           }
  530   
  531           private String _name;
  532       }
  533       
  534       private static class ElementsByTagNameNSNodeList extends ElementsNodeList
  535       {
  536           ElementsByTagNameNSNodeList ( Dom root, String uri, String local )
  537           {
  538               super( root );
  539   
  540               _uri = uri == null ? "" : uri;
  541               _local = local;
  542           }
  543   
  544           protected boolean match ( Dom element )
  545           {
  546               if (!(_uri.equals( "*" ) ? true : _node_getNamespaceURI( element ).equals( _uri )))
  547                   return false;
  548   
  549               return _local.equals( "*" ) ? true : _node_getLocalName( element ).equals( _local );
  550              }
  551   
  552           private String _uri;
  553           private String _local;
  554       }
  555       
  556       //////////////////////////////////////////////////////////////////////////////////////
  557       //////////////////////////////////////////////////////////////////////////////////////
  558       //////////////////////////////////////////////////////////////////////////////////////
  559   
  560       public static Document _domImplementation_createDocument (
  561           Locale l, String u, String n, DocumentType t )
  562       {
  563           Document d;
  564   
  565           if (l.noSync())         { l.enter(); try { return domImplementation_createDocument( l, u, n, t ); } finally { l.exit(); } }
  566           else synchronized ( l ) { l.enter(); try { return domImplementation_createDocument( l, u, n, t ); } finally { l.exit(); } }
  567       }
  568   
  569       public static Document domImplementation_createDocument (
  570           Locale l, String namespaceURI, String qualifiedName, DocumentType doctype )
  571       {
  572           validateQualifiedName( qualifiedName, namespaceURI, false );
  573           
  574           Cur c = l.tempCur();
  575   
  576           c.createDomDocumentRoot();
  577   
  578           Document doc = (Document) c.getDom();
  579           
  580           c.next();
  581   
  582           c.createElement( l.makeQualifiedQName( namespaceURI, qualifiedName ) );
  583   
  584           if (doctype != null)
  585               throw new RuntimeException( "Not impl" );
  586   
  587           c.toParent();
  588   
  589           try
  590           {
  591               Locale.autoTypeDocument( c, null, null );
  592           }
  593           catch (XmlException e )
  594           {
  595               throw new XmlRuntimeException( e );
  596           }
  597   
  598           c.release();
  599           
  600           return doc;
  601       }
  602       
  603       //////////////////////////////////////////////////////////////////////////////////////
  604       //////////////////////////////////////////////////////////////////////////////////////
  605       //////////////////////////////////////////////////////////////////////////////////////
  606   
  607       public static boolean _domImplementation_hasFeature ( Locale l, String feature, String version )
  608       {
  609           if (feature == null)
  610               return false;
  611           
  612           if (version != null && version.length() > 0 &&
  613                 !version.equals( "1.0" ) && !version.equals( "2.0" ))
  614           {
  615               return false;
  616           }
  617   
  618           if (feature.equalsIgnoreCase( "core" ))
  619               return true;
  620           
  621           if (feature.equalsIgnoreCase( "xml" ))
  622               return true;
  623   
  624           return false;
  625       }
  626   
  627       //////////////////////////////////////////////////////////////////////////////////////
  628       //////////////////////////////////////////////////////////////////////////////////////
  629       //////////////////////////////////////////////////////////////////////////////////////
  630       
  631       public static Element _document_getDocumentElement ( Dom d )
  632       {
  633           Locale l = d.locale();
  634   
  635           Dom e;
  636   
  637           if (l.noSync())         { l.enter(); try { e = document_getDocumentElement( d ); } finally { l.exit(); } }
  638           else synchronized ( l ) { l.enter(); try { e = document_getDocumentElement( d ); } finally { l.exit(); } }
  639   
  640           return (Element) e;
  641       }
  642   
  643       public static Dom document_getDocumentElement ( Dom d )
  644       {
  645           for ( d = firstChild( d ) ; d != null ; d = nextSibling( d ) )
  646           {
  647               if (d.nodeType() == ELEMENT)
  648                   return d;
  649           }
  650   
  651           return null;
  652       }
  653   
  654       //////////////////////////////////////////////////////////////////////////////////////
  655       //////////////////////////////////////////////////////////////////////////////////////
  656       //////////////////////////////////////////////////////////////////////////////////////
  657   
  658       public static DocumentFragment _document_createDocumentFragment ( Dom d )
  659       {
  660           Locale l = d.locale();
  661   
  662           Dom f;
  663   
  664           if (l.noSync())         { l.enter(); try { f = document_createDocumentFragment( d ); } finally { l.exit(); } }
  665           else synchronized ( l ) { l.enter(); try { f = document_createDocumentFragment( d ); } finally { l.exit(); } }
  666   
  667           return (DocumentFragment) f;
  668       }
  669       
  670       public static Dom document_createDocumentFragment ( Dom d )
  671       {
  672           Cur c = d.locale().tempCur();
  673   
  674           c.createDomDocFragRoot();
  675   
  676           Dom f = c.getDom();
  677           
  678           c.release();
  679   
  680           return f;
  681       }
  682   
  683       //////////////////////////////////////////////////////////////////////////////////////
  684       //////////////////////////////////////////////////////////////////////////////////////
  685       //////////////////////////////////////////////////////////////////////////////////////
  686   
  687       public static Element _document_createElement ( Dom d, String name )
  688       {
  689           Locale l = d.locale();
  690   
  691           Dom e;
  692   
  693           if (l.noSync())         { l.enter(); try { e = document_createElement( d, name ); } finally { l.exit(); } }
  694           else synchronized ( l ) { l.enter(); try { e = document_createElement( d, name ); } finally { l.exit(); } }
  695   
  696           return (Element) e;
  697       }
  698   
  699       public static Dom document_createElement ( Dom d, String name )
  700       {
  701           validateName( name );
  702           
  703           Locale l = d.locale();
  704   
  705           Cur c = l.tempCur();
  706   
  707           c.createElement( l.makeQualifiedQName( "", name ) );
  708   
  709           Dom e = c.getDom();
  710   
  711           c.release();
  712           ((Xobj.ElementXobj)e)._canHavePrefixUri = false;
  713           return e;
  714       }
  715   
  716       //////////////////////////////////////////////////////////////////////////////////////
  717       //////////////////////////////////////////////////////////////////////////////////////
  718       //////////////////////////////////////////////////////////////////////////////////////
  719   
  720       public static Element _document_createElementNS ( Dom d, String uri, String qname )
  721       {
  722           Locale l = d.locale();
  723   
  724           Dom e;
  725   
  726           if (l.noSync())         { l.enter(); try { e = document_createElementNS( d, uri, qname ); } finally { l.exit(); } }
  727           else synchronized ( l ) { l.enter(); try { e = document_createElementNS( d, uri, qname ); } finally { l.exit(); } }
  728   
  729           return (Element) e;
  730       }
  731   
  732       public static Dom document_createElementNS ( Dom d, String uri, String qname )
  733       {
  734           validateQualifiedName( qname, uri, false );
  735           
  736           Locale l = d.locale();
  737           
  738           Cur c = l.tempCur();
  739           
  740           c.createElement( l.makeQualifiedQName( uri, qname ) );
  741   
  742           Dom e = c.getDom();
  743   
  744           c.release();
  745   
  746           return e;
  747       }
  748       
  749       //////////////////////////////////////////////////////////////////////////////////////
  750       //////////////////////////////////////////////////////////////////////////////////////
  751       //////////////////////////////////////////////////////////////////////////////////////
  752   
  753       public static Attr _document_createAttribute ( Dom d, String name )
  754       {
  755           Locale l = d.locale();
  756   
  757           Dom a;
  758   
  759           if (l.noSync())         { l.enter(); try { a = document_createAttribute( d, name ); } finally { l.exit(); } }
  760           else synchronized ( l ) { l.enter(); try { a = document_createAttribute( d, name ); } finally { l.exit(); } }
  761   
  762           return (Attr) a;
  763       }
  764   
  765       public static Dom document_createAttribute ( Dom d, String name )
  766       {
  767           validateName( name );
  768   
  769           Locale l = d.locale();
  770   
  771           Cur c = l.tempCur();
  772   
  773           c.createAttr( l.makeQualifiedQName( "", name ) );
  774   
  775           Dom e = c.getDom();
  776   
  777           c.release();
  778           ((Xobj.AttrXobj)e)._canHavePrefixUri = false;
  779           return e;
  780       }
  781   
  782       //////////////////////////////////////////////////////////////////////////////////////
  783       //////////////////////////////////////////////////////////////////////////////////////
  784       //////////////////////////////////////////////////////////////////////////////////////
  785   
  786       public static Attr _document_createAttributeNS ( Dom d, String uri, String qname )
  787       {
  788           Locale l = d.locale();
  789   
  790           Dom a;
  791   
  792           if (l.noSync())         { l.enter(); try { a = document_createAttributeNS( d, uri, qname ); } finally { l.exit(); } }
  793           else synchronized ( l ) { l.enter(); try { a = document_createAttributeNS( d, uri, qname ); } finally { l.exit(); } }
  794   
  795           return (Attr) a;
  796       }
  797       
  798       public static Dom document_createAttributeNS ( Dom d, String uri, String qname )
  799       {
  800           validateQualifiedName( qname, uri, true );
  801   
  802           Locale l = d.locale();
  803   
  804           Cur c = l.tempCur();
  805   
  806           c.createAttr( l.makeQualifiedQName( uri, qname ) );
  807   
  808           Dom e = c.getDom();
  809   
  810           c.release();
  811   
  812           return e;
  813       }
  814   
  815       //////////////////////////////////////////////////////////////////////////////////////
  816       //////////////////////////////////////////////////////////////////////////////////////
  817       //////////////////////////////////////////////////////////////////////////////////////
  818   
  819       public static Comment _document_createComment ( Dom d, String data )
  820       {
  821           Locale l = d.locale();
  822   
  823           Dom c;
  824   
  825           if (l.noSync())         { l.enter(); try { c = document_createComment( d, data ); } finally { l.exit(); } }
  826           else synchronized ( l ) { l.enter(); try { c = document_createComment( d, data ); } finally { l.exit(); } }
  827   
  828           return (Comment) c;
  829       }
  830       
  831       public static Dom document_createComment ( Dom d, String data )
  832       {
  833           Locale l = d.locale();
  834   
  835           Cur c = l.tempCur();
  836   
  837           c.createComment();
  838   
  839           Dom comment = c.getDom();
  840   
  841           if (data != null)
  842           {
  843               c.next();
  844               c.insertString( data );
  845           }
  846   
  847           c.release();
  848   
  849           return comment;
  850       }
  851   
  852       //////////////////////////////////////////////////////////////////////////////////////
  853       //////////////////////////////////////////////////////////////////////////////////////
  854       //////////////////////////////////////////////////////////////////////////////////////
  855   
  856       public static ProcessingInstruction _document_createProcessingInstruction ( Dom d, String target, String data )
  857       {
  858           Locale l = d.locale();
  859   
  860           Dom pi;
  861   
  862           if (l.noSync())         { l.enter(); try { pi = document_createProcessingInstruction( d, target, data ); } finally { l.exit(); } }
  863           else synchronized ( l ) { l.enter(); try { pi = document_createProcessingInstruction( d, target, data ); } finally { l.exit(); } }
  864   
  865           return (ProcessingInstruction) pi;
  866       }
  867       
  868       public static Dom document_createProcessingInstruction ( Dom d, String target, String data )
  869       {
  870           if (target == null)
  871               throw new IllegalArgumentException( "Target is null" );
  872               
  873           if (target.length() == 0)
  874               throw new IllegalArgumentException( "Target is empty" );
  875               
  876           if (!XMLChar.isValidName( target ))
  877               throw new InvalidCharacterError( "Target has an invalid character" );
  878           
  879           if (Locale.beginsWithXml( target ) && target.length() == 3)
  880               throw new InvalidCharacterError( "Invalid target - is 'xml'" );
  881           
  882           Locale l = d.locale();
  883   
  884           Cur c = l.tempCur();
  885   
  886           c.createProcinst( target );
  887   
  888           Dom pi = c.getDom();
  889   
  890           if (data != null)
  891           {
  892               c.next();
  893               c.insertString( data );
  894           }
  895   
  896           c.release();
  897   
  898           return pi;
  899       }
  900   
  901       //////////////////////////////////////////////////////////////////////////////////////
  902       //////////////////////////////////////////////////////////////////////////////////////
  903       //////////////////////////////////////////////////////////////////////////////////////
  904   
  905       public static CDATASection _document_createCDATASection ( Dom d, String data )
  906       {
  907           return (CDATASection) document_createCDATASection( d, data );
  908       }
  909       
  910       public static Dom document_createCDATASection ( Dom d, String data )
  911       {
  912           TextNode t = d.locale().createCdataNode();
  913   
  914           if (data == null)
  915               data = "";
  916   
  917           t.setChars( data, 0, data.length() );
  918           
  919           return t;
  920       }
  921   
  922       //////////////////////////////////////////////////////////////////////////////////////
  923       //////////////////////////////////////////////////////////////////////////////////////
  924       //////////////////////////////////////////////////////////////////////////////////////
  925   
  926       public static Text _document_createTextNode ( Dom d, String data )
  927       {
  928           return (Text) document_createTextNode( d, data );
  929       }
  930   
  931       public static CharNode document_createTextNode ( Dom d, String data )
  932       {
  933           TextNode t = d.locale().createTextNode();
  934   
  935           if (data == null)
  936               data = "";
  937   
  938           t.setChars( data, 0, data.length() );
  939   
  940           return t;
  941       }
  942   
  943       //////////////////////////////////////////////////////////////////////////////////////
  944       //////////////////////////////////////////////////////////////////////////////////////
  945       //////////////////////////////////////////////////////////////////////////////////////
  946   
  947       public static EntityReference _document_createEntityReference ( Dom d, String name )
  948       {
  949           throw new RuntimeException( "Not implemented" );
  950       }
  951   
  952       //////////////////////////////////////////////////////////////////////////////////////
  953       //////////////////////////////////////////////////////////////////////////////////////
  954       //////////////////////////////////////////////////////////////////////////////////////
  955   
  956       public static Element _document_getElementById ( Dom d, String elementId )
  957       {
  958           throw new RuntimeException( "Not implemented" );
  959       }
  960   
  961       //////////////////////////////////////////////////////////////////////////////////////
  962       //////////////////////////////////////////////////////////////////////////////////////
  963       //////////////////////////////////////////////////////////////////////////////////////
  964   
  965       public static NodeList _document_getElementsByTagName ( Dom d, String name )
  966       {
  967           Locale l = d.locale();
  968   
  969           if (l.noSync())         { l.enter(); try { return document_getElementsByTagName( d, name ); } finally { l.exit(); } }
  970           else synchronized ( l ) { l.enter(); try { return document_getElementsByTagName( d, name ); } finally { l.exit(); } }
  971       }
  972       
  973       public static NodeList document_getElementsByTagName ( Dom d, String name )
  974       {
  975           return new ElementsByTagNameNodeList( d, name );
  976       }
  977   
  978       //////////////////////////////////////////////////////////////////////////////////////
  979       //////////////////////////////////////////////////////////////////////////////////////
  980       //////////////////////////////////////////////////////////////////////////////////////
  981   
  982       public static NodeList _document_getElementsByTagNameNS ( Dom d, String uri, String local )
  983       {
  984           Locale l = d.locale();
  985   
  986           if (l.noSync())         { l.enter(); try { return document_getElementsByTagNameNS( d, uri, local ); } finally { l.exit(); } }
  987           else synchronized ( l ) { l.enter(); try { return document_getElementsByTagNameNS( d, uri, local ); } finally { l.exit(); } }
  988       }
  989       
  990       public static NodeList document_getElementsByTagNameNS ( Dom d, String uri, String local )
  991       {
  992           return new ElementsByTagNameNSNodeList( d, uri, local );
  993       }
  994   
  995       //////////////////////////////////////////////////////////////////////////////////////
  996       //////////////////////////////////////////////////////////////////////////////////////
  997       //////////////////////////////////////////////////////////////////////////////////////
  998   
  999       public static DOMImplementation _document_getImplementation ( Dom d )
 1000       {
 1001           return (DOMImplementation) d.locale();
 1002       }
 1003   
 1004       //////////////////////////////////////////////////////////////////////////////////////
 1005       //////////////////////////////////////////////////////////////////////////////////////
 1006       //////////////////////////////////////////////////////////////////////////////////////
 1007   
 1008       public static Node _document_importNode ( Dom d, Node n, boolean deep )
 1009       {
 1010           Locale l = d.locale();
 1011           Dom i;
 1012   
 1013   //        // TODO - need to wrap this in sync ..
 1014   //        if (n instanceof Dom)
 1015   //            i = node_cloneNode( (Dom) n, deep, m );
 1016   //        else
 1017   // TODO -- I'm importing my own nodes through DOM methods!  -- make this faster
 1018           {
 1019               if (l.noSync())         { l.enter(); try { i = document_importNode( d, n, deep ); } finally { l.exit(); } }
 1020               else synchronized ( l ) { l.enter(); try { i = document_importNode( d, n, deep ); } finally { l.exit(); } }
 1021           }
 1022   
 1023           return (Node) i;
 1024       }
 1025   
 1026       public static Dom document_importNode ( Dom d, Node n, boolean deep )
 1027       {
 1028           if (n == null)
 1029               return null;
 1030           
 1031           Dom i;
 1032   
 1033           boolean copyChildren = false;
 1034           
 1035           switch ( n.getNodeType() )
 1036           {
 1037           case DOCUMENT :
 1038               throw new NotSupportedError( "Document nodes may not be imported" );
 1039   
 1040           case DOCTYPE :
 1041               throw new NotSupportedError( "Document type nodes may not be imported" );
 1042   
 1043           case ELEMENT :
 1044           {
 1045               String local = n.getLocalName();
 1046   
 1047               if (local == null || local.length() == 0)
 1048                   i = document_createElement( d, n.getNodeName() );
 1049               else
 1050               {
 1051                   String prefix = n.getPrefix();
 1052                   String name = prefix == null || prefix.length() == 0 ? local : prefix + ":" + local;
 1053                   String uri = n.getNamespaceURI();
 1054   
 1055                   if (uri == null || uri.length() == 0)
 1056                       i = document_createElement( d, name );
 1057                   else
 1058                       i = document_createElementNS( d, uri, name );
 1059               }
 1060   
 1061               NamedNodeMap attrs = n.getAttributes();
 1062   
 1063               for ( int a = 0 ; a < attrs.getLength() ; a++ )
 1064                   attributes_setNamedItem( i, document_importNode( d, attrs.item( a ), true ) );
 1065   
 1066               copyChildren = deep;
 1067               
 1068               break;
 1069           }
 1070   
 1071           case ATTR :
 1072           {
 1073               String local = n.getLocalName();
 1074   
 1075               if (local == null || local.length() == 0)
 1076                   i = document_createAttribute( d, n.getNodeName() );
 1077               else
 1078               {
 1079                   String prefix = n.getPrefix();
 1080                   String name = prefix == null || prefix.length() == 0 ? local : prefix + ":" + local;
 1081                   String uri = n.getNamespaceURI();
 1082   
 1083                   if (uri == null || uri.length() == 0)
 1084                       i = document_createAttribute( d, name );
 1085                   else
 1086                       i = document_createAttributeNS( d, uri, name );
 1087               }
 1088   
 1089               copyChildren = true;
 1090               
 1091               break;
 1092           }
 1093           
 1094           case DOCFRAG :
 1095           {
 1096               i = document_createDocumentFragment( d );
 1097               
 1098               copyChildren = deep;
 1099   
 1100               break;
 1101           }
 1102           
 1103           case PROCINST :
 1104           {
 1105               i = document_createProcessingInstruction( d, n.getNodeName(), n.getNodeValue() );
 1106               break;
 1107           }
 1108           
 1109           case COMMENT :
 1110           {
 1111               i = document_createComment( d, n.getNodeValue() );
 1112               break;
 1113           }
 1114           
 1115           case TEXT :
 1116           {
 1117               i = document_createTextNode( d, n.getNodeValue() );
 1118               break;
 1119           }
 1120           
 1121           case CDATA :
 1122           {
 1123               i = document_createCDATASection( d, n.getNodeValue() );
 1124               break;
 1125           }
 1126               
 1127           case ENTITYREF :
 1128           case ENTITY :
 1129           case NOTATION :
 1130               throw new RuntimeException( "Not impl" );
 1131   
 1132           default : throw new RuntimeException( "Unknown kind" );
 1133           }
 1134   
 1135           if (copyChildren)
 1136           {
 1137               NodeList children = n.getChildNodes();
 1138               
 1139               for ( int c = 0 ; c < children.getLength() ; c++ )
 1140                   node_insertBefore( i, document_importNode( d, children.item( c ), true ), null);
 1141           }
 1142   
 1143           return i;
 1144       }
 1145   
 1146       //////////////////////////////////////////////////////////////////////////////////////
 1147       //////////////////////////////////////////////////////////////////////////////////////
 1148       //////////////////////////////////////////////////////////////////////////////////////
 1149   
 1150       public static DocumentType _document_getDoctype ( Dom d )
 1151       {
 1152           Locale l = d.locale();
 1153   
 1154           Dom dt;
 1155   
 1156           if (l.noSync())         { l.enter(); try { dt = document_getDoctype( d ); } finally { l.exit(); } }
 1157           else synchronized ( l ) { l.enter(); try { dt = document_getDoctype( d ); } finally { l.exit(); } }
 1158   
 1159           return (DocumentType) dt;
 1160       }
 1161   
 1162       public static Dom document_getDoctype ( Dom d )
 1163       {
 1164           return null;
 1165       }
 1166   
 1167       //////////////////////////////////////////////////////////////////////////////////////
 1168       //////////////////////////////////////////////////////////////////////////////////////
 1169       //////////////////////////////////////////////////////////////////////////////////////
 1170   
 1171       public static Document _node_getOwnerDocument ( Dom n )
 1172       {
 1173           Locale l = n.locale();
 1174   
 1175           Dom d;
 1176   
 1177           if (l.noSync())         { l.enter(); try { d = node_getOwnerDocument( n ); } finally { l.exit(); } }
 1178           else synchronized ( l ) { l.enter(); try { d = node_getOwnerDocument( n ); } finally { l.exit(); } }
 1179   
 1180           return (Document) d;
 1181       }
 1182       
 1183       public static Dom node_getOwnerDocument ( Dom n )
 1184       {
 1185           if (n.nodeType() == DOCUMENT)
 1186               return null;
 1187           
 1188           Locale l = n.locale();
 1189   
 1190           if (l._ownerDoc == null)
 1191           {
 1192               Cur c = l.tempCur();
 1193               c.createDomDocumentRoot();
 1194               l._ownerDoc = c.getDom();
 1195               c.release();
 1196           }
 1197   
 1198           return l._ownerDoc;
 1199       }
 1200   
 1201       //////////////////////////////////////////////////////////////////////////////////////
 1202       //////////////////////////////////////////////////////////////////////////////////////
 1203       //////////////////////////////////////////////////////////////////////////////////////
 1204   
 1205       public static Node _node_getParentNode ( Dom n )
 1206       {
 1207           Locale l = n.locale();
 1208   
 1209           Dom p;
 1210           
 1211           if (l.noSync())         { l.enter(); try { p = node_getParentNode( n ); } finally { l.exit(); } }
 1212           else synchronized ( l ) { l.enter(); try { p = node_getParentNode( n ); } finally { l.exit(); } }
 1213   
 1214           return (Node) p;
 1215       }
 1216   
 1217       public static Dom node_getParentNode ( Dom n )
 1218       {
 1219           Cur c = null;
 1220   
 1221           switch ( n.nodeType() )
 1222           {
 1223           case DOCUMENT :
 1224           case DOCFRAG :
 1225           case ATTR :
 1226               break;
 1227               
 1228           case PROCINST :
 1229           case COMMENT :
 1230           case ELEMENT :
 1231           {
 1232               if (!(c = n.tempCur()).toParentRaw())
 1233               {
 1234                   c.release();
 1235                   c = null;
 1236               }
 1237   
 1238               break;
 1239           }
 1240   
 1241           case TEXT :
 1242           case CDATA :
 1243           {
 1244               if ((c = n.tempCur()) != null)
 1245                   c.toParent();
 1246   
 1247               break;
 1248           }
 1249               
 1250           case ENTITYREF :
 1251               throw new RuntimeException( "Not impl" );
 1252               
 1253           case ENTITY :
 1254           case DOCTYPE :
 1255           case NOTATION :
 1256               throw new RuntimeException( "Not impl" );
 1257               
 1258           default : throw new RuntimeException( "Unknown kind" );
 1259           }
 1260   
 1261           if (c == null)
 1262               return null;
 1263           
 1264           Dom d = c.getDom();
 1265           
 1266           c.release();
 1267           
 1268           return d;
 1269       }
 1270   
 1271       //////////////////////////////////////////////////////////////////////////////////////
 1272       //////////////////////////////////////////////////////////////////////////////////////
 1273       //////////////////////////////////////////////////////////////////////////////////////
 1274   
 1275       public static Node _node_getFirstChild ( Dom n )
 1276       {
 1277           Locale l = n.locale();
 1278   
 1279           Dom fc;
 1280           assert n instanceof Xobj;
 1281           Xobj node = (Xobj)n;
 1282           if (!node.isVacant())
 1283           {
 1284               if (node.isFirstChildPtrDomUsable())
 1285                   return (Node) node._firstChild;
 1286               Xobj lastAttr = node.lastAttr();
 1287               if (lastAttr != null &&
 1288                   lastAttr.isNextSiblingPtrDomUsable())
 1289                   return (Xobj.NodeXobj) lastAttr._nextSibling;
 1290               if (node.isExistingCharNodesValueUsable())
 1291                   return node._charNodesValue;
 1292           }
 1293           if (l.noSync())         {  fc = node_getFirstChild( n );  }
 1294           else synchronized ( l ) {  fc = node_getFirstChild( n ); }
 1295   
 1296           return (Node) fc;
 1297       }
 1298   
 1299       public static Dom node_getFirstChild ( Dom n )
 1300       {
 1301           Dom fc = null;
 1302   
 1303           switch ( n.nodeType() )
 1304           {
 1305           case TEXT :
 1306           case CDATA :
 1307           case PROCINST :
 1308           case COMMENT :
 1309               break;
 1310               
 1311           case ENTITYREF :
 1312               throw new RuntimeException( "Not impl" );
 1313               
 1314           case ENTITY :
 1315           case DOCTYPE :
 1316           case NOTATION :
 1317               throw new RuntimeException( "Not impl" );
 1318               
 1319           case ELEMENT :
 1320           case DOCUMENT :
 1321           case DOCFRAG :
 1322           case ATTR :
 1323           {
 1324   
 1325               Xobj node = (Xobj) n;
 1326               node.ensureOccupancy();
 1327               if (node.isFirstChildPtrDomUsable())
 1328                   return (Xobj.NodeXobj) node._firstChild;
 1329               Xobj lastAttr = node.lastAttr();
 1330               if (lastAttr != null)
 1331               {
 1332                   if (lastAttr.isNextSiblingPtrDomUsable())
 1333                       return (Xobj.NodeXobj) lastAttr._nextSibling;
 1334                   else if (lastAttr.isCharNodesAfterUsable())
 1335                       return (CharNode) lastAttr._charNodesAfter;
 1336               }
 1337               if (node.isCharNodesValueUsable())
 1338                   return node._charNodesValue;
 1339   
 1340   
 1341               break;
 1342           }
 1343           }
 1344   
 1345           // TODO - handle entity refs here ...
 1346   
 1347           return fc;
 1348       }
 1349       
 1350       //////////////////////////////////////////////////////////////////////////////////////
 1351       //////////////////////////////////////////////////////////////////////////////////////
 1352       //////////////////////////////////////////////////////////////////////////////////////
 1353   
 1354       public static Node _node_getLastChild ( Dom n )
 1355       {
 1356           Locale l = n.locale();
 1357   
 1358           Dom lc;
 1359   
 1360           if (l.noSync())         { l.enter(); try { lc = node_getLastChild( n ); } finally { l.exit(); } }
 1361           else synchronized ( l ) { l.enter(); try { lc = node_getLastChild( n ); } finally { l.exit(); } }
 1362   
 1363           return (Node) lc;
 1364       }
 1365       
 1366       public static Dom node_getLastChild ( Dom n )
 1367       {
 1368           switch ( n.nodeType() )
 1369           {
 1370               case TEXT :
 1371               case CDATA :
 1372               case PROCINST :
 1373               case COMMENT :
 1374                   return null;
 1375   
 1376               case ENTITYREF :
 1377                   throw new RuntimeException( "Not impl" );
 1378   
 1379               case ENTITY :
 1380               case DOCTYPE :
 1381               case NOTATION :
 1382                   throw new RuntimeException( "Not impl" );
 1383   
 1384               case ELEMENT :
 1385               case DOCUMENT :
 1386               case DOCFRAG :
 1387               case ATTR :
 1388                   break;
 1389           }
 1390           
 1391           Dom lc = null;
 1392           CharNode nodes;
 1393   
 1394           Cur c = n.tempCur();
 1395   
 1396           if (c.toLastChild())
 1397           {
 1398               lc = c.getDom();
 1399               
 1400               c.skip();
 1401   
 1402               if ((nodes = c.getCharNodes()) != null)
 1403                   lc = null;
 1404           }
 1405           else
 1406           {
 1407               c.next();
 1408               nodes = c.getCharNodes();
 1409           }
 1410   
 1411           if (lc == null && nodes != null)
 1412           {
 1413               while ( nodes._next != null )
 1414                   nodes = nodes._next;
 1415   
 1416               lc = nodes;
 1417           }
 1418   
 1419           c.release();
 1420   
 1421           // TODO - handle entity refs here ...
 1422   
 1423           return lc;
 1424       }
 1425   
 1426       //////////////////////////////////////////////////////////////////////////////////////
 1427       //////////////////////////////////////////////////////////////////////////////////////
 1428       //////////////////////////////////////////////////////////////////////////////////////
 1429   
 1430       public static Node _node_getNextSibling ( Dom n )
 1431       {
 1432           Locale l = n.locale();
 1433   
 1434           Dom ns;
 1435   
 1436           if (l.noSync())         {  ns = node_getNextSibling( n );  }
 1437           else synchronized ( l ) {  ns = node_getNextSibling( n );  }
 1438   
 1439           return (Node) ns;
 1440       }
 1441   
 1442       public static Dom node_getNextSibling ( Dom n )
 1443       {
 1444           Dom ns = null;
 1445   
 1446           switch ( n.nodeType() )
 1447           {
 1448           case DOCUMENT :
 1449           case DOCFRAG :
 1450           case ATTR :
 1451               break;
 1452               
 1453           case TEXT :
 1454           case CDATA :
 1455           {
 1456               CharNode cn = (CharNode) n;
 1457               //if src is attr & next is null , ret null;
 1458               //if src is container and
 1459               // a) this node is aftertext && src._nextSib = null; ret null
 1460               // b) this node is value && src._fc = null; ret null
 1461   
 1462   
 1463               if (! (cn._src instanceof Xobj) )
 1464                   return null;
 1465               Xobj src = (Xobj) cn._src;
 1466               //if src is attr this node is always value and
 1467               // next is always the next ptr of the attr
 1468               src._charNodesAfter =
 1469                                       Cur.updateCharNodes( src._locale, src, src._charNodesAfter, src._cchAfter );
 1470   
 1471               src._charNodesValue =
 1472                                     Cur.updateCharNodes( src._locale, src, src._charNodesValue, src._cchValue );
 1473   
 1474               if (cn._next != null)
 1475               {
 1476                   ns = cn._next;
 1477                   break;
 1478               }
 1479               boolean isThisNodeAfterText = cn.isNodeAftertext();
 1480   
 1481               if (isThisNodeAfterText)
 1482                   ns = (Xobj.NodeXobj) src._nextSibling;
 1483               else     //srcValue or attribute source
 1484                   ns = (Xobj.NodeXobj) src._firstChild;
 1485               break;
 1486   
 1487           }
 1488   
 1489           case PROCINST :
 1490           case COMMENT :
 1491           case ELEMENT :
 1492           {
 1493               assert n instanceof Xobj: "PI, Comments and Elements always backed up by Xobj";
 1494               Xobj node = (Xobj) n;
 1495               node.ensureOccupancy();
 1496               if (node.isNextSiblingPtrDomUsable())
 1497                   return
 1498                       (Xobj.NodeXobj) node._nextSibling;
 1499               if (node.isCharNodesAfterUsable())
 1500                   return node._charNodesAfter;
 1501               break;
 1502           }
 1503   
 1504           case ENTITY :
 1505           case NOTATION :
 1506           case ENTITYREF :
 1507           case DOCTYPE :
 1508               throw new RuntimeException( "Not implemented" );
 1509           }
 1510   
 1511           // TODO - handle entity refs here ...
 1512   
 1513           return ns;
 1514       }
 1515   
 1516       //////////////////////////////////////////////////////////////////////////////////////
 1517       //////////////////////////////////////////////////////////////////////////////////////
 1518       //////////////////////////////////////////////////////////////////////////////////////
 1519   
 1520       public static Node _node_getPreviousSibling ( Dom n )
 1521       {
 1522           Locale l = n.locale();
 1523   
 1524           Dom ps;
 1525   
 1526           if (l.noSync())         {  ps = node_getPreviousSibling( n ); }
 1527           else synchronized ( l ) {  ps = node_getPreviousSibling( n ); }
 1528   
 1529           return (Node) ps;
 1530       }
 1531       
 1532       public static Dom node_getPreviousSibling ( Dom n )
 1533       {
 1534           Dom prev = null;
 1535           Dom temp;
 1536           switch (n.nodeType())
 1537           {
 1538           case TEXT:
 1539           case CDATA:
 1540               {
 1541                   assert n instanceof CharNode: "Text/CData should be a CharNode";
 1542                   CharNode node = (CharNode) n;
 1543                   if (!(node._src instanceof Xobj))
 1544                       return null;
 1545                   Xobj src = (Xobj) node._src;
 1546                   src.ensureOccupancy();
 1547                   boolean isThisNodeAfterText = node.isNodeAftertext();
 1548                   prev = node._prev;
 1549                   if (prev == null)
 1550                       prev = isThisNodeAfterText ? (Dom) src :
 1551                           src._charNodesValue;
 1552                   break;
 1553               }
 1554           default:
 1555               {
 1556                   assert n instanceof Xobj;
 1557                   Xobj node = (Xobj) n;
 1558                   prev = (Dom) node._prevSibling;
 1559                   if (prev == null && node._parent != null)
 1560                       prev = (Dom) node_getFirstChild((Dom) node._parent);
 1561               }
 1562           }
 1563           temp = (Dom) prev;
 1564           while (temp != null &&
 1565               (temp = node_getNextSibling(temp)) != n)
 1566               prev = temp;
 1567           return prev;
 1568       }
 1569   
 1570       //////////////////////////////////////////////////////////////////////////////////////
 1571       //////////////////////////////////////////////////////////////////////////////////////
 1572       //////////////////////////////////////////////////////////////////////////////////////
 1573   
 1574       public static boolean _node_hasAttributes ( Dom n )
 1575       {
 1576           Locale l = n.locale();
 1577   
 1578           if (l.noSync())         { l.enter(); try { return node_hasAttributes( n ); } finally { l.exit(); } }
 1579           else synchronized ( l ) { l.enter(); try { return node_hasAttributes( n ); } finally { l.exit(); } }
 1580       }
 1581       
 1582       public static boolean node_hasAttributes ( Dom n )
 1583       {
 1584           boolean hasAttrs = false;
 1585           
 1586           if (n.nodeType() == ELEMENT)
 1587           {
 1588               Cur c = n.tempCur();
 1589               
 1590               hasAttrs = c.hasAttrs();
 1591   
 1592               c.release();
 1593           }
 1594   
 1595           return hasAttrs;
 1596       }
 1597   
 1598       //////////////////////////////////////////////////////////////////////////////////////
 1599       //////////////////////////////////////////////////////////////////////////////////////
 1600       //////////////////////////////////////////////////////////////////////////////////////
 1601   
 1602       public static boolean _node_isSupported ( Dom n, String feature, String version )
 1603       {
 1604           return _domImplementation_hasFeature( n.locale(), feature, version );
 1605       }
 1606   
 1607       //////////////////////////////////////////////////////////////////////////////////////
 1608       //////////////////////////////////////////////////////////////////////////////////////
 1609       //////////////////////////////////////////////////////////////////////////////////////
 1610   
 1611       public static void _node_normalize ( Dom n )
 1612       {
 1613           Locale l = n.locale();
 1614   
 1615           if (l.noSync())         { l.enter(); try { node_normalize( n ); } finally { l.exit(); } }
 1616           else synchronized ( l ) { l.enter(); try { node_normalize( n ); } finally { l.exit(); } }
 1617       }
 1618       
 1619       public static void node_normalize ( Dom n )
 1620       {
 1621           switch ( n.nodeType() )
 1622           {
 1623               case TEXT :
 1624               case CDATA :
 1625               case PROCINST :
 1626               case COMMENT :
 1627                   return;
 1628   
 1629               case ENTITYREF :
 1630                   throw new RuntimeException( "Not impl" );
 1631   
 1632               case ENTITY :
 1633               case DOCTYPE :
 1634               case NOTATION :
 1635                   throw new RuntimeException( "Not impl" );
 1636   
 1637               case ELEMENT :
 1638               case DOCUMENT :
 1639               case DOCFRAG :
 1640               case ATTR :
 1641                   break;
 1642           }
 1643   
 1644           Cur c = n.tempCur();
 1645   
 1646           c.push();
 1647   
 1648           do
 1649           {
 1650               c.nextWithAttrs();
 1651   
 1652               CharNode cn = c.getCharNodes();
 1653   
 1654               if (cn != null)
 1655               {
 1656                   if (!c.isText())
 1657                   {
 1658                       while ( cn != null )
 1659                       {
 1660                           cn.setChars( null, 0, 0 );
 1661                           cn = CharNode.remove( cn, cn );
 1662                       }
 1663                   }
 1664                   else if (cn._next != null)
 1665                   {
 1666                       while ( cn._next != null )
 1667                       {
 1668                           cn.setChars( null, 0, 0 );
 1669                           cn = CharNode.remove( cn, cn._next );
 1670                       }
 1671   
 1672                       cn._cch = Integer.MAX_VALUE;
 1673                   }
 1674   
 1675                   c.setCharNodes( cn );
 1676               }
 1677           }
 1678           while ( ! c.isAtEndOfLastPush() );
 1679   
 1680           c.release();
 1681           
 1682           n.locale().invalidateDomCaches(n);
 1683       }
 1684   
 1685       //////////////////////////////////////////////////////////////////////////////////////
 1686       //////////////////////////////////////////////////////////////////////////////////////
 1687       //////////////////////////////////////////////////////////////////////////////////////
 1688   
 1689       public static boolean _node_hasChildNodes ( Dom n )
 1690       {
 1691           // TODO - make this faster
 1692           return _node_getFirstChild( n ) != null;
 1693       }
 1694   
 1695       //////////////////////////////////////////////////////////////////////////////////////
 1696       //////////////////////////////////////////////////////////////////////////////////////
 1697       //////////////////////////////////////////////////////////////////////////////////////
 1698   
 1699       public static Node _node_appendChild ( Dom p, Node newChild )
 1700       {
 1701           return _node_insertBefore( p, newChild, null );
 1702       }
 1703   
 1704       //////////////////////////////////////////////////////////////////////////////////////
 1705       //////////////////////////////////////////////////////////////////////////////////////
 1706       //////////////////////////////////////////////////////////////////////////////////////
 1707   
 1708       public static Node _node_replaceChild ( Dom p, Node newChild, Node oldChild )
 1709       {
 1710           Locale l = p.locale();
 1711   
 1712           if (newChild == null)
 1713               throw new IllegalArgumentException( "Child to add is null" );
 1714   
 1715           if (oldChild == null)
 1716               throw new NotFoundErr( "Child to replace is null" );
 1717   
 1718           Dom nc;
 1719   
 1720           if (!(newChild instanceof Dom) || (nc = (Dom) newChild).locale() != l)
 1721               throw new WrongDocumentErr( "Child to add is from another document" );
 1722   
 1723           Dom oc = null;
 1724   
 1725           if (!(oldChild instanceof Dom) || (oc = (Dom) oldChild).locale() != l)
 1726               throw new WrongDocumentErr( "Child to replace is from another document" );
 1727   
 1728           Dom d;
 1729   
 1730           if (l.noSync())         { l.enter(); try { d = node_replaceChild( p, nc, oc ); } finally { l.exit(); } }
 1731           else synchronized ( l ) { l.enter(); try { d = node_replaceChild( p, nc, oc ); } finally { l.exit(); } }
 1732   
 1733           return (Node) d;
 1734       }
 1735       
 1736       public static Dom node_replaceChild ( Dom p, Dom newChild, Dom oldChild )
 1737       {
 1738           // Remove the old child firest to avoid a dom exception raised
 1739           // when inserting two document elements
 1740           
 1741           Dom nextNode = node_getNextSibling( oldChild );
 1742           
 1743           node_removeChild( p, oldChild );
 1744   
 1745           try
 1746           {
 1747               node_insertBefore( p, newChild, nextNode );
 1748           }
 1749           catch ( DOMException e )
 1750           {
 1751               node_insertBefore( p, oldChild, nextNode );
 1752   
 1753               throw e;
 1754           }
 1755   
 1756           return oldChild;
 1757       }
 1758   
 1759       //////////////////////////////////////////////////////////////////////////////////////
 1760       //////////////////////////////////////////////////////////////////////////////////////
 1761       //////////////////////////////////////////////////////////////////////////////////////
 1762   
 1763       public static Node _node_insertBefore ( Dom p, Node newChild, Node refChild )
 1764       {
 1765           Locale l = p.locale();
 1766   
 1767           if (newChild == null)
 1768               throw new IllegalArgumentException( "Child to add is null" );
 1769   
 1770           Dom nc;
 1771           
 1772           if (!(newChild instanceof Dom) || (nc = (Dom) newChild).locale() != l)
 1773               throw new WrongDocumentErr( "Child to add is from another document" );
 1774   
 1775           Dom rc = null;
 1776   
 1777           if (refChild != null)
 1778           {
 1779               if (!(refChild instanceof Dom) || (rc = (Dom) refChild).locale() != l)
 1780                   throw new WrongDocumentErr( "Reference child is from another document" );
 1781           }
 1782   
 1783           Dom d;
 1784   
 1785           if (l.noSync())         { l.enter(); try { d = node_insertBefore( p, nc, rc ); } finally { l.exit(); } }
 1786           else synchronized ( l ) { l.enter(); try { d = node_insertBefore( p, nc, rc ); } finally { l.exit(); } }
 1787   
 1788           return (Node) d;
 1789       }
 1790   
 1791       public static Dom node_insertBefore ( Dom p, Dom nc, Dom rc )
 1792       {
 1793           assert nc != null;
 1794   
 1795           // Inserting self before self is a no-op
 1796   
 1797           if (nc == rc)
 1798               return nc;
 1799   
 1800           if (rc != null && parent( rc ) != p)
 1801               throw new NotFoundErr( "RefChild is not a child of this node" );
 1802   
 1803           // TODO - obey readonly status of a substree
 1804   
 1805           int nck = nc.nodeType();
 1806   
 1807           if (nck == DOCFRAG)
 1808           {
 1809               for ( Dom c = firstChild( nc ) ; c != null ; c = nextSibling( c ) )
 1810                   validateNewChild( p, c );
 1811   
 1812               for ( Dom c = firstChild( nc ) ; c != null ;  )
 1813               {
 1814                   Dom n = nextSibling( c );
 1815   
 1816                   if (rc == null)
 1817                       append( c, p );
 1818                   else
 1819                       insert( c, rc );
 1820                   
 1821                   c = n;
 1822               }
 1823               
 1824               return nc;
 1825           }
 1826   
 1827           //
 1828           // Make sure the new child is allowed here
 1829           //
 1830   
 1831           validateNewChild( p, nc );
 1832   
 1833           //
 1834           // Orphan the child before establishing a new parent
 1835           //
 1836   
 1837           remove( nc );
 1838           
 1839           int pk = p.nodeType();
 1840   
 1841           // Only these nodes can be modifiable parents
 1842           assert pk == ATTR || pk == DOCFRAG || pk == DOCUMENT || pk == ELEMENT;
 1843   
 1844           switch ( nck )
 1845           {
 1846           case ELEMENT :
 1847           case COMMENT :
 1848           case PROCINST :
 1849           {
 1850               if (rc == null)
 1851               {
 1852                   Cur cTo = p.tempCur();
 1853                   cTo.toEnd();
 1854                   Cur.moveNode( (Xobj) nc, cTo );
 1855                   cTo.release();
 1856               }
 1857               else
 1858               {
 1859                   int rck = rc.nodeType();
 1860   
 1861                   if (rck == TEXT || rck == CDATA)
 1862                   {
 1863                       // Quick and dirty impl....
 1864                       
 1865                       ArrayList charNodes = new ArrayList();
 1866                       
 1867                       while ( rc != null && (rc.nodeType() == TEXT || rc.nodeType() == CDATA ) )
 1868                       {
 1869                           Dom next = nextSibling( rc );
 1870                           charNodes.add( remove( rc ) );
 1871                           rc = next;
 1872                       }
 1873   
 1874                       if (rc == null)
 1875                           append( nc, p );
 1876                       else
 1877                           insert( nc, rc );
 1878   
 1879                       rc = nextSibling( nc );
 1880   
 1881                       for ( int i = 0 ; i < charNodes.size() ; i++ )
 1882                       {
 1883                           Dom n = (Dom) charNodes.get( i );
 1884   
 1885                           if (rc == null)
 1886                               append( n, p );
 1887                           else
 1888                               insert( n, rc );
 1889                       }
 1890                   }
 1891                   else if (rck == ENTITYREF)
 1892                   {
 1893                       throw new RuntimeException( "Not implemented" );
 1894                   }
 1895                   else
 1896                   {
 1897                       assert rck == ELEMENT || rck == PROCINST || rck == COMMENT;
 1898                       Cur cTo = rc.tempCur();
 1899                       Cur.moveNode( (Xobj) nc, cTo );
 1900                       cTo.release();
 1901                   }
 1902               }
 1903   
 1904               break;
 1905           }
 1906           
 1907           case TEXT :
 1908           case CDATA :
 1909           {
 1910               CharNode n = (CharNode) nc;
 1911   
 1912               assert n._prev == null && n._next == null;
 1913   
 1914               CharNode refCharNode = null;
 1915               Cur c = p.tempCur();
 1916               
 1917               if (rc == null)
 1918                   c.toEnd();
 1919               else
 1920               {
 1921                   int rck = rc.nodeType();
 1922                   
 1923                   if (rck == TEXT || rck == CDATA)
 1924                       c.moveToCharNode( refCharNode = (CharNode) rc );
 1925                   else if (rck == ENTITYREF)
 1926                       throw new RuntimeException( "Not implemented" );
 1927                   else
 1928                       c.moveToDom( rc );
 1929               }
 1930   
 1931               CharNode nodes = c.getCharNodes();
 1932   
 1933               nodes = CharNode.insertNode( nodes, n, refCharNode );
 1934   
 1935               c.insertChars( n._src, n._off, n._cch );
 1936   
 1937               c.setCharNodes( nodes );
 1938   
 1939               c.release();
 1940   
 1941               break;
 1942           }
 1943   
 1944           case ENTITYREF :
 1945           {
 1946               throw new RuntimeException( "Not implemented" );
 1947           }
 1948               
 1949           case DOCTYPE :
 1950           {
 1951               // TODO - don't actually insert this here, associate it with the
 1952               // doc??  Hmm .. Perhaps I should disallow insertion into the tree
 1953               // at all.
 1954               
 1955               throw new RuntimeException( "Not implemented" );
 1956           }
 1957               
 1958           default : throw new RuntimeException( "Unexpected child node type" );
 1959           }
 1960           
 1961           return nc;
 1962       }
 1963       
 1964       //////////////////////////////////////////////////////////////////////////////////////
 1965       //////////////////////////////////////////////////////////////////////////////////////
 1966       //////////////////////////////////////////////////////////////////////////////////////
 1967   
 1968       public static Node _node_removeChild ( Dom p, Node child )
 1969       {
 1970           Locale l = p.locale();
 1971   
 1972           if (child == null)
 1973               throw new NotFoundErr( "Child to remove is null" );
 1974   
 1975           Dom c;
 1976           
 1977           if (!(child instanceof Dom) || (c = (Dom) child).locale() != l)
 1978               throw new WrongDocumentErr( "Child to remove is from another document" );
 1979   
 1980           Dom d;
 1981   
 1982           if (l.noSync())         { l.enter(); try { d = node_removeChild( p, c ); } finally { l.exit(); } }
 1983           else synchronized ( l ) { l.enter(); try { d = node_removeChild( p, c ); } finally { l.exit(); } }
 1984   
 1985           return (Node) d;
 1986       }
 1987   
 1988       public static Dom node_removeChild ( Dom parent, Dom child )
 1989       {
 1990           if (parent( child ) != parent)
 1991               throw new NotFoundErr( "Child to remove is not a child of given parent" );
 1992           
 1993           switch ( child.nodeType() )
 1994           {
 1995           case DOCUMENT :
 1996           case DOCFRAG :
 1997           case ATTR :
 1998               throw new IllegalStateException();
 1999               
 2000           case ELEMENT :
 2001           case PROCINST :
 2002           case COMMENT :
 2003               removeNode( child );
 2004               break;
 2005   
 2006           case TEXT :
 2007           case CDATA :
 2008           {
 2009               Cur c = child.tempCur();
 2010               
 2011               CharNode nodes = c.getCharNodes();
 2012   
 2013               CharNode cn = (CharNode) child;
 2014   
 2015               assert cn._src instanceof Dom;
 2016   
 2017               cn.setChars( c.moveChars( null, cn._cch ), c._offSrc, c._cchSrc );
 2018               
 2019               c.setCharNodes( CharNode.remove( nodes, cn ) );
 2020   
 2021               c.release();
 2022   
 2023               break;
 2024           }
 2025               
 2026           case ENTITYREF :
 2027               throw new RuntimeException( "Not impl" );
 2028               
 2029           case ENTITY :
 2030           case DOCTYPE :
 2031           case NOTATION :
 2032               throw new RuntimeException( "Not impl" );
 2033               
 2034           default : throw new RuntimeException( "Unknown kind" );
 2035           }
 2036   
 2037           return child;
 2038       }
 2039   
 2040       //////////////////////////////////////////////////////////////////////////////////////
 2041       //////////////////////////////////////////////////////////////////////////////////////
 2042       //////////////////////////////////////////////////////////////////////////////////////
 2043   
 2044       public static Node _node_cloneNode ( Dom n, boolean deep )
 2045       {
 2046           Locale l = n.locale();
 2047   
 2048           Dom c;
 2049   
 2050           if (l.noSync())         { l.enter(); try { c = node_cloneNode( n, deep ); } finally { l.exit(); } }
 2051           else synchronized ( l ) { l.enter(); try { c = node_cloneNode( n, deep ); } finally { l.exit(); } }
 2052   
 2053           return (Node) c;
 2054       }
 2055       
 2056       public static Dom node_cloneNode ( Dom n, boolean deep )
 2057       {
 2058           Locale l = n.locale();
 2059           
 2060           Dom clone = null;
 2061           
 2062           if (!deep)
 2063           {
 2064               Cur shallow = null;
 2065               
 2066               switch ( n.nodeType() )
 2067               {
 2068               case DOCUMENT :
 2069                   shallow = l.tempCur();
 2070                   shallow.createDomDocumentRoot();
 2071                   break;
 2072                   
 2073               case DOCFRAG :
 2074                   shallow = l.tempCur();
 2075                   shallow.createDomDocFragRoot();
 2076                   break;
 2077                   
 2078               case ELEMENT :
 2079               {
 2080                   shallow = l.tempCur();
 2081                   shallow.createElement( n.getQName() );
 2082   
 2083                   Element elem = (Element) shallow.getDom();
 2084                   NamedNodeMap attrs = ((Element) n).getAttributes();
 2085                   
 2086                   for ( int i = 0 ; i < attrs.getLength() ; i++ )
 2087                       elem.setAttributeNodeNS( (Attr) attrs.item( i ).cloneNode( true ) );
 2088                   
 2089                   break;
 2090               }
 2091                   
 2092               case ATTR :
 2093                   shallow = l.tempCur();
 2094                   shallow.createAttr( n.getQName() );
 2095                   break;
 2096   
 2097               case PROCINST :
 2098               case COMMENT :
 2099               case TEXT :
 2100               case CDATA :
 2101               case ENTITYREF :
 2102               case ENTITY :
 2103               case DOCTYPE :
 2104               case NOTATION :
 2105                   break;
 2106               }
 2107   
 2108               if (shallow != null)
 2109               {
 2110                   clone = shallow.getDom();
 2111                   shallow.release();
 2112               }
 2113           }
 2114   
 2115           if (clone == null)
 2116           {
 2117               switch ( n.nodeType() )
 2118               {
 2119               case DOCUMENT :
 2120               case DOCFRAG :
 2121               case ATTR :
 2122               case ELEMENT :
 2123               case PROCINST :
 2124               case COMMENT :
 2125               {
 2126                   Cur cClone = l.tempCur();
 2127                   Cur cSrc = n.tempCur();
 2128                   cSrc.copyNode( cClone );
 2129                   clone = cClone.getDom();
 2130                   cClone.release();
 2131                   cSrc.release();
 2132   
 2133                   break;
 2134               }
 2135   
 2136               case TEXT :
 2137               case CDATA :
 2138               {
 2139                   Cur c = n.tempCur();
 2140   
 2141                   CharNode cn = n.nodeType() == TEXT ? l.createTextNode() : l.createCdataNode();
 2142   
 2143                   cn.setChars( c.getChars( ((CharNode) n)._cch ), c._offSrc, c._cchSrc );
 2144   
 2145                   clone = cn;
 2146   
 2147                   c.release();
 2148   
 2149                   break;
 2150               }
 2151   
 2152               case ENTITYREF :
 2153               case ENTITY :
 2154               case DOCTYPE :
 2155               case NOTATION :
 2156                   throw new RuntimeException( "Not impl" );
 2157   
 2158               default : throw new RuntimeException( "Unknown kind" );
 2159               }
 2160           }
 2161   
 2162           return clone;
 2163       }
 2164   
 2165       //////////////////////////////////////////////////////////////////////////////////////
 2166       //////////////////////////////////////////////////////////////////////////////////////
 2167       //////////////////////////////////////////////////////////////////////////////////////
 2168   
 2169       public static String _node_getLocalName ( Dom n )
 2170       {
 2171           if (! n.nodeCanHavePrefixUri() ) return null;
 2172           QName name = n.getQName();
 2173           return name == null ? "" : name.getLocalPart();
 2174       }
 2175   
 2176       //////////////////////////////////////////////////////////////////////////////////////
 2177       //////////////////////////////////////////////////////////////////////////////////////
 2178       //////////////////////////////////////////////////////////////////////////////////////
 2179   
 2180       public static String _node_getNamespaceURI ( Dom n )
 2181       {
 2182           if (! n.nodeCanHavePrefixUri() ) return null;
 2183           QName name = n.getQName();
 2184           // TODO - should return the correct namespace for xmlns ...
 2185           return name == null ? "":
 2186               //name.getNamespaceURI().equals("")? null:
 2187               name.getNamespaceURI();
 2188       }
 2189   
 2190       //////////////////////////////////////////////////////////////////////////////////////
 2191       //////////////////////////////////////////////////////////////////////////////////////
 2192       //////////////////////////////////////////////////////////////////////////////////////
 2193   
 2194       public static void _node_setPrefix ( Dom n, String prefix )
 2195       {
 2196           Locale l = n.locale();
 2197   
 2198           if (l.noSync())         { l.enter(); try { node_setPrefix( n, prefix ); } finally { l.exit(); } }
 2199           else synchronized ( l ) { l.enter(); try { node_setPrefix( n, prefix ); } finally { l.exit(); } }
 2200       }
 2201       
 2202       public static void node_setPrefix ( Dom n, String prefix )
 2203       {
 2204           // TODO - make it possible to set the prefix of an xmlns
 2205           // TODO - test to make use prefix: xml maps to the predefined namespace
 2206           // if set???? hmmm ... perhaps I should not allow the setting of any
 2207           // prefixes which start with xml unless the namespace is the predefined
 2208           // one and the prefix is 'xml' all other prefixes which start with
 2209           // 'xml' should fail.
 2210   
 2211           if (n.nodeType() == ELEMENT || n.nodeType() == ATTR)
 2212           {
 2213               Cur c = n.tempCur();
 2214               QName name = c.getName();
 2215               String uri = name.getNamespaceURI();
 2216               String local = name.getLocalPart();
 2217   
 2218               prefix = validatePrefix( prefix, uri, local, n.nodeType() == ATTR );
 2219                                     
 2220               c.setName( n.locale().makeQName( uri, local, prefix ) );
 2221               
 2222               c.release();
 2223           }
 2224           else
 2225               validatePrefix( prefix, "", "", false );
 2226       }
 2227   
 2228       //////////////////////////////////////////////////////////////////////////////////////
 2229       //////////////////////////////////////////////////////////////////////////////////////
 2230       //////////////////////////////////////////////////////////////////////////////////////
 2231   
 2232       public static String _node_getPrefix ( Dom n )
 2233       {
 2234           if (! n.nodeCanHavePrefixUri() ) return null;
 2235           QName name = n.getQName();
 2236           return name == null ? "" :
 2237               name.getPrefix();
 2238       }
 2239   
 2240       //////////////////////////////////////////////////////////////////////////////////////
 2241       //////////////////////////////////////////////////////////////////////////////////////
 2242       //////////////////////////////////////////////////////////////////////////////////////
 2243   
 2244       public static String _node_getNodeName ( Dom n )
 2245       {
 2246           switch ( n.nodeType() )
 2247           {
 2248           case CDATA     : return "#cdata-section";
 2249           case COMMENT   : return "#comment";
 2250           case DOCFRAG   : return "#document-fragment";
 2251           case DOCUMENT  : return "#document";
 2252           case PROCINST  : return n.getQName().getLocalPart();
 2253           case TEXT      : return "#text";
 2254                            
 2255           case ATTR      :
 2256           case ELEMENT   :
 2257           {
 2258               QName name = n.getQName();
 2259               String prefix = name.getPrefix();
 2260               return prefix.length() == 0 ? name.getLocalPart() : prefix + ":" + name.getLocalPart();
 2261           }
 2262   
 2263           case DOCTYPE   :
 2264           case ENTITY    :
 2265           case ENTITYREF :
 2266           case NOTATION  :
 2267               throw new RuntimeException( "Not impl" );
 2268                                              
 2269           default : throw new RuntimeException( "Unknown node type" );
 2270           }
 2271       }
 2272   
 2273       //////////////////////////////////////////////////////////////////////////////////////
 2274       //////////////////////////////////////////////////////////////////////////////////////
 2275       //////////////////////////////////////////////////////////////////////////////////////
 2276   
 2277       public static short _node_getNodeType ( Dom n )
 2278       {
 2279           return (short) n.nodeType();
 2280       }
 2281   
 2282       //////////////////////////////////////////////////////////////////////////////////////
 2283       //////////////////////////////////////////////////////////////////////////////////////
 2284       //////////////////////////////////////////////////////////////////////////////////////
 2285   
 2286       public static void _node_setNodeValue ( Dom n, String nodeValue )
 2287       {
 2288           Locale l = n.locale();
 2289   
 2290           if (l.noSync())         { l.enter(); try { node_setNodeValue( n, nodeValue ); } finally { l.exit(); } }
 2291           else synchronized ( l ) { l.enter(); try { node_setNodeValue( n, nodeValue ); } finally { l.exit(); } }
 2292       }
 2293       
 2294       public static void node_setNodeValue ( Dom n, String nodeValue )
 2295       {
 2296           if (nodeValue == null)
 2297               nodeValue = "";
 2298           
 2299           switch ( n.nodeType() )
 2300           {
 2301               case TEXT :
 2302               case CDATA :
 2303               {
 2304                   CharNode cn = (CharNode) n;
 2305   
 2306                   Cur c;
 2307   
 2308                   if ((c = cn.tempCur()) != null)
 2309                   {
 2310                       c.moveChars( null, cn._cch );
 2311                       cn._cch = nodeValue.length();
 2312                       c.insertString( nodeValue );
 2313                       c.release();
 2314                   }
 2315                   else
 2316                       cn.setChars( nodeValue, 0, nodeValue.length() );
 2317   
 2318                   break;
 2319               }
 2320                   
 2321               case ATTR :
 2322               {
 2323                   // Try to set an exisiting text node to contain the new value
 2324                   
 2325                   NodeList children = ((Node) n).getChildNodes();
 2326   
 2327                   while ( children.getLength() > 1 )
 2328                       node_removeChild( n, (Dom) children.item( 1 ) );
 2329                   
 2330                   if (children.getLength() == 0)
 2331                   {
 2332                       TextNode tn = n.locale().createTextNode();
 2333                       tn.setChars( nodeValue, 0, nodeValue.length() );
 2334                       node_insertBefore( n, tn, null );
 2335                   }
 2336                   else
 2337                   {
 2338                       assert children.getLength() == 1;
 2339                       children.item( 0 ).setNodeValue( nodeValue );
 2340                   }
 2341                   if (((Xobj.AttrXobj) n).isId())
 2342                   {
 2343                       Dom d = DomImpl.node_getOwnerDocument(n);
 2344                       String val = node_getNodeValue(n);
 2345                       if (d instanceof Xobj.DocumentXobj)
 2346                       {
 2347                           ((Xobj.DocumentXobj) d).removeIdElement(val);
 2348                           ((Xobj.DocumentXobj) d).addIdElement(nodeValue,
 2349                               attr_getOwnerElement(n));
 2350                       }
 2351                   }
 2352   
 2353                   break;
 2354               }
 2355               
 2356               case PROCINST :
 2357               case COMMENT :
 2358               {
 2359                   Cur c = n.tempCur();
 2360                   c.next();
 2361                   
 2362                   c.getChars( -1 );
 2363                   c.moveChars( null, c._cchSrc );
 2364                   c.insertString( nodeValue );
 2365                   
 2366                   c.release();
 2367   
 2368                   break;
 2369               }
 2370           }
 2371       }
 2372   
 2373       //////////////////////////////////////////////////////////////////////////////////////
 2374       //////////////////////////////////////////////////////////////////////////////////////
 2375       //////////////////////////////////////////////////////////////////////////////////////
 2376   
 2377       public static String _node_getNodeValue ( Dom n )
 2378       {
 2379           Locale l = n.locale();
 2380   
 2381           if (l.noSync())         { return node_getNodeValue( n ); }
 2382           else synchronized ( l ) { return node_getNodeValue( n ); }
 2383       }
 2384   
 2385       public static String node_getNodeValue ( Dom n )
 2386       {
 2387           String s = null;
 2388   
 2389           switch ( n.nodeType() )
 2390           {
 2391           case ATTR :
 2392           case PROCINST :
 2393           case COMMENT :
 2394           {
 2395               s = ((Xobj)n).getValueAsString();
 2396               break;
 2397           }
 2398   
 2399           case TEXT :
 2400           case CDATA :
 2401           {
 2402               assert n instanceof CharNode: "Text/CData should be a CharNode";
 2403               CharNode node = (CharNode) n;
 2404               if (! (node._src instanceof Xobj) )
 2405                   s = CharUtil.getString( node._src, node._off, node._cch );
 2406               else{
 2407                   Xobj src = (Xobj) node._src;
 2408                   src.ensureOccupancy();
 2409                   boolean isThisNodeAfterText = node.isNodeAftertext();
 2410                   if( isThisNodeAfterText ){
 2411                       src._charNodesAfter =
 2412                           Cur.updateCharNodes( src._locale, src, src._charNodesAfter, src._cchAfter );
 2413                       s = src.getCharsAfterAsString(node._off, node._cch);
 2414                   }
 2415                   else{
 2416                       src._charNodesValue =
 2417                          Cur.updateCharNodes( src._locale, src, src._charNodesValue, src._cchValue );
 2418                       s = src.getCharsValueAsString(node._off, node._cch);
 2419                   }
 2420   
 2421               }
 2422               break;
 2423           }
 2424           }
 2425   
 2426           return s;
 2427       }
 2428   
 2429       //////////////////////////////////////////////////////////////////////////////////////
 2430       //////////////////////////////////////////////////////////////////////////////////////
 2431       //////////////////////////////////////////////////////////////////////////////////////
 2432   
 2433       public static Object _node_getUserData ( Dom n, String key )
 2434       {
 2435           throw new RuntimeException( "DOM Level 3 Not implemented" );
 2436       }
 2437   
 2438       //////////////////////////////////////////////////////////////////////////////////////
 2439       //////////////////////////////////////////////////////////////////////////////////////
 2440       //////////////////////////////////////////////////////////////////////////////////////
 2441   
 2442       public static Object _node_setUserData ( Dom n, String key, Object data, UserDataHandler handler )
 2443       {
 2444           throw new RuntimeException( "DOM Level 3 Not implemented" );
 2445       }
 2446   
 2447       //////////////////////////////////////////////////////////////////////////////////////
 2448       //////////////////////////////////////////////////////////////////////////////////////
 2449       //////////////////////////////////////////////////////////////////////////////////////
 2450   
 2451       public static Object _node_getFeature ( Dom n, String feature, String version )
 2452       {
 2453           throw new RuntimeException( "DOM Level 3 Not implemented" );
 2454       }
 2455   
 2456       //////////////////////////////////////////////////////////////////////////////////////
 2457       //////////////////////////////////////////////////////////////////////////////////////
 2458       //////////////////////////////////////////////////////////////////////////////////////
 2459   
 2460       public static boolean _node_isEqualNode ( Dom n, Node arg )
 2461       {
 2462           throw new RuntimeException( "DOM Level 3 Not implemented" );
 2463       }
 2464   
 2465       //////////////////////////////////////////////////////////////////////////////////////
 2466       //////////////////////////////////////////////////////////////////////////////////////
 2467       //////////////////////////////////////////////////////////////////////////////////////
 2468   
 2469       public static boolean _node_isSameNode ( Dom n, Node arg )
 2470       {
 2471           throw new RuntimeException( "DOM Level 3 Not implemented" );
 2472       }
 2473   
 2474       //////////////////////////////////////////////////////////////////////////////////////
 2475       //////////////////////////////////////////////////////////////////////////////////////
 2476       //////////////////////////////////////////////////////////////////////////////////////
 2477   
 2478       public static String _node_lookupNamespaceURI ( Dom n, String prefix )
 2479       {
 2480           throw new RuntimeException( "DOM Level 3 Not implemented" );
 2481       }
 2482   
 2483       //////////////////////////////////////////////////////////////////////////////////////
 2484       //////////////////////////////////////////////////////////////////////////////////////
 2485       //////////////////////////////////////////////////////////////////////////////////////
 2486   
 2487       public static boolean _node_isDefaultNamespace ( Dom n, String namespaceURI )
 2488       {
 2489           throw new RuntimeException( "DOM Level 3 Not implemented" );
 2490       }
 2491       
 2492       //////////////////////////////////////////////////////////////////////////////////////
 2493       //////////////////////////////////////////////////////////////////////////////////////
 2494       //////////////////////////////////////////////////////////////////////////////////////
 2495   
 2496       public static String _node_lookupPrefix ( Dom n, String namespaceURI )
 2497       {
 2498           throw new RuntimeException( "DOM Level 3 Not implemented" );
 2499       }
 2500   
 2501       //////////////////////////////////////////////////////////////////////////////////////
 2502       //////////////////////////////////////////////////////////////////////////////////////
 2503       //////////////////////////////////////////////////////////////////////////////////////
 2504   
 2505       public static void _node_setTextContent ( Dom n, String textContent )
 2506       {
 2507           throw new RuntimeException( "DOM Level 3 Not implemented" );
 2508       }
 2509   
 2510       //////////////////////////////////////////////////////////////////////////////////////
 2511       //////////////////////////////////////////////////////////////////////////////////////
 2512       //////////////////////////////////////////////////////////////////////////////////////
 2513   
 2514       public static String _node_getTextContent ( Dom n )
 2515       {
 2516           throw new RuntimeException( "DOM Level 3 Not implemented" );
 2517       }
 2518   
 2519       //////////////////////////////////////////////////////////////////////////////////////
 2520       //////////////////////////////////////////////////////////////////////////////////////
 2521       //////////////////////////////////////////////////////////////////////////////////////
 2522   
 2523       public static short _node_compareDocumentPosition ( Dom n, Node other )
 2524       {
 2525           throw new RuntimeException( "DOM Level 3 Not implemented" );
 2526       }
 2527   
 2528       //////////////////////////////////////////////////////////////////////////////////////
 2529       //////////////////////////////////////////////////////////////////////////////////////
 2530       //////////////////////////////////////////////////////////////////////////////////////
 2531   
 2532       public static String _node_getBaseURI ( Dom n )
 2533       {
 2534           throw new RuntimeException( "DOM Level 3 Not implemented" );
 2535       }
 2536   
 2537       //////////////////////////////////////////////////////////////////////////////////////
 2538       //////////////////////////////////////////////////////////////////////////////////////
 2539       //////////////////////////////////////////////////////////////////////////////////////
 2540   
 2541       public static Node _childNodes_item ( Dom n, int i )
 2542       {
 2543           Locale l = n.locale();
 2544   
 2545           Dom d;
 2546           if (i == 0) return _node_getFirstChild(n);
 2547           if (l.noSync())         { d = childNodes_item( n, i ); }
 2548           else synchronized ( l ) { d = childNodes_item( n, i ); }
 2549   
 2550           return (Node) d;
 2551       }
 2552       
 2553       public static Dom childNodes_item ( Dom n, int i )
 2554       {
 2555           if (i < 0)
 2556               return null;
 2557           
 2558           switch ( n.nodeType() )
 2559           {
 2560               case TEXT :
 2561               case CDATA :
 2562               case PROCINST :
 2563               case COMMENT :
 2564                   return null;
 2565   
 2566               case ENTITYREF :
 2567                   throw new RuntimeException( "Not impl" );
 2568   
 2569               case ENTITY :
 2570               case DOCTYPE :
 2571               case NOTATION :
 2572                   throw new RuntimeException( "Not impl" );
 2573   
 2574               case ELEMENT :
 2575               case DOCUMENT :
 2576               case DOCFRAG :
 2577               case ATTR :
 2578                   break;
 2579           }
 2580   	    if ( i == 0 )
 2581   	        return node_getFirstChild ( n );
 2582           return n.locale().findDomNthChild(n, i);
 2583       }
 2584   
 2585       //////////////////////////////////////////////////////////////////////////////////////
 2586       //////////////////////////////////////////////////////////////////////////////////////
 2587       //////////////////////////////////////////////////////////////////////////////////////
 2588   
 2589       public static int _childNodes_getLength ( Dom n )
 2590       {
 2591           Locale l = n.locale();
 2592           assert n instanceof Xobj;
 2593           int count;
 2594           Xobj node = (Xobj) n;
 2595           if (!node.isVacant() &&
 2596               (count = node.getDomZeroOneChildren()) < 2)
 2597               return count;
 2598           if (l.noSync())         {  return childNodes_getLength( n );  }
 2599           else synchronized ( l ) {  return childNodes_getLength( n );  }
 2600       }
 2601       
 2602       public static int childNodes_getLength ( Dom n )
 2603       {
 2604           switch ( n.nodeType() )
 2605           {
 2606               case TEXT :
 2607               case CDATA :
 2608               case PROCINST :
 2609               case COMMENT :
 2610                   return 0;
 2611   
 2612               case ENTITYREF :
 2613                   throw new RuntimeException( "Not impl" );
 2614   
 2615               case ENTITY :
 2616               case DOCTYPE :
 2617               case NOTATION :
 2618                   throw new RuntimeException( "Not impl" );
 2619   
 2620               case ELEMENT :
 2621               case DOCUMENT :
 2622               case DOCFRAG :
 2623               case ATTR :
 2624                   break;
 2625           }
 2626   
 2627           int count;
 2628           assert n instanceof Xobj;
 2629           Xobj node = (Xobj) n;
 2630           node.ensureOccupancy();
 2631           if ((count = node.getDomZeroOneChildren()) < 2)
 2632               return count;
 2633           return n.locale().domLength(n);
 2634       }
 2635   
 2636       //////////////////////////////////////////////////////////////////////////////////////
 2637       //////////////////////////////////////////////////////////////////////////////////////
 2638       //////////////////////////////////////////////////////////////////////////////////////
 2639   
 2640       public static String _element_getTagName ( Dom e )
 2641       {
 2642           return _node_getNodeName( e );
 2643       }
 2644   
 2645       //////////////////////////////////////////////////////////////////////////////////////
 2646       //////////////////////////////////////////////////////////////////////////////////////
 2647       //////////////////////////////////////////////////////////////////////////////////////
 2648   
 2649       public static Attr _element_getAttributeNode ( Dom e, String name )
 2650       {
 2651           return (Attr) _attributes_getNamedItem( e, name );
 2652       }
 2653   
 2654       //////////////////////////////////////////////////////////////////////////////////////
 2655       //////////////////////////////////////////////////////////////////////////////////////
 2656       //////////////////////////////////////////////////////////////////////////////////////
 2657   
 2658       public static Attr _element_getAttributeNodeNS ( Dom e, String uri, String local )
 2659       {
 2660           return (Attr) _attributes_getNamedItemNS( e, uri, local );
 2661       }
 2662   
 2663       //////////////////////////////////////////////////////////////////////////////////////
 2664       //////////////////////////////////////////////////////////////////////////////////////
 2665       //////////////////////////////////////////////////////////////////////////////////////
 2666   
 2667       public static Attr _element_setAttributeNode ( Dom e, Attr newAttr )
 2668       {
 2669           return (Attr) _attributes_setNamedItem( e, newAttr );
 2670       }
 2671       
 2672       //////////////////////////////////////////////////////////////////////////////////////
 2673       //////////////////////////////////////////////////////////////////////////////////////
 2674       //////////////////////////////////////////////////////////////////////////////////////
 2675   
 2676       public static Attr _element_setAttributeNodeNS ( Dom e, Attr newAttr )
 2677       {
 2678           return (Attr) _attributes_setNamedItemNS( e, newAttr );
 2679       }
 2680   
 2681       //////////////////////////////////////////////////////////////////////////////////////
 2682       //////////////////////////////////////////////////////////////////////////////////////
 2683       //////////////////////////////////////////////////////////////////////////////////////
 2684   
 2685       public static String _element_getAttribute ( Dom e, String name )
 2686       {
 2687           Node a = _attributes_getNamedItem( e, name );
 2688           return a == null ? "" : a.getNodeValue();
 2689       }
 2690   
 2691       //////////////////////////////////////////////////////////////////////////////////////
 2692       //////////////////////////////////////////////////////////////////////////////////////
 2693       //////////////////////////////////////////////////////////////////////////////////////
 2694   
 2695       public static String _element_getAttributeNS ( Dom e, String uri, String local )
 2696       {
 2697           Node a = _attributes_getNamedItemNS( e, uri, local );
 2698           return a == null ? "" : a.getNodeValue();
 2699       }
 2700   
 2701       //////////////////////////////////////////////////////////////////////////////////////
 2702       //////////////////////////////////////////////////////////////////////////////////////
 2703       //////////////////////////////////////////////////////////////////////////////////////
 2704   
 2705       public static boolean _element_hasAttribute ( Dom e, String name )
 2706       {
 2707           return _attributes_getNamedItem( e, name ) != null;
 2708       }
 2709   
 2710       //////////////////////////////////////////////////////////////////////////////////////
 2711       //////////////////////////////////////////////////////////////////////////////////////
 2712       //////////////////////////////////////////////////////////////////////////////////////
 2713   
 2714       public static boolean _element_hasAttributeNS ( Dom e, String uri, String local )
 2715       {
 2716           return _attributes_getNamedItemNS( e, uri, local ) != null;
 2717       }
 2718   
 2719       //////////////////////////////////////////////////////////////////////////////////////
 2720       //////////////////////////////////////////////////////////////////////////////////////
 2721       //////////////////////////////////////////////////////////////////////////////////////
 2722   
 2723       public static void _element_removeAttribute ( Dom e, String name )
 2724       {
 2725           try
 2726           {
 2727               _attributes_removeNamedItem( e, name );
 2728           }
 2729           catch ( NotFoundErr ex )
 2730           {
 2731           }
 2732       }
 2733   
 2734       //////////////////////////////////////////////////////////////////////////////////////
 2735       //////////////////////////////////////////////////////////////////////////////////////
 2736       //////////////////////////////////////////////////////////////////////////////////////
 2737   
 2738       public static void _element_removeAttributeNS ( Dom e, String uri, String local )
 2739       {
 2740           try
 2741           {
 2742               _attributes_removeNamedItemNS( e, uri, local );
 2743           }
 2744           catch ( NotFoundErr ex )
 2745           {
 2746           }
 2747       }
 2748   
 2749       //////////////////////////////////////////////////////////////////////////////////////
 2750       //////////////////////////////////////////////////////////////////////////////////////
 2751       //////////////////////////////////////////////////////////////////////////////////////
 2752   
 2753       public static Attr _element_removeAttributeNode ( Dom e, Attr oldAttr )
 2754       {
 2755           if (oldAttr == null)
 2756               throw new NotFoundErr( "Attribute to remove is null" );
 2757           
 2758           if (oldAttr.getOwnerElement() != e)
 2759               throw new NotFoundErr( "Attribute to remove does not belong to this element" );
 2760   
 2761           return (Attr) _attributes_removeNamedItem( e, oldAttr.getNodeName() );
 2762       }
 2763   
 2764       //////////////////////////////////////////////////////////////////////////////////////
 2765       //////////////////////////////////////////////////////////////////////////////////////
 2766       //////////////////////////////////////////////////////////////////////////////////////
 2767   
 2768       public static void _element_setAttribute ( Dom e, String name, String value )
 2769       {
 2770           // TODO - validate all attr/element names in all apprpraite
 2771           // methdos
 2772   
 2773           Locale l = e.locale();
 2774   
 2775           if (l.noSync())         { l.enter(); try { element_setAttribute( e, name, value ); } finally { l.exit(); } }
 2776           else synchronized ( l ) { l.enter(); try { element_setAttribute( e, name, value ); } finally { l.exit(); } }
 2777       }
 2778       
 2779       public static void element_setAttribute ( Dom e, String name, String value )
 2780       {
 2781           Dom a = attributes_getNamedItem( e, name );
 2782   
 2783           if (a == null)
 2784           {
 2785               a = document_createAttribute( node_getOwnerDocument( e ), name );
 2786               attributes_setNamedItem( e, a );
 2787           }
 2788           
 2789           node_setNodeValue( a, value );
 2790       }
 2791   
 2792       //////////////////////////////////////////////////////////////////////////////////////
 2793       //////////////////////////////////////////////////////////////////////////////////////
 2794       //////////////////////////////////////////////////////////////////////////////////////
 2795   
 2796       public static void _element_setAttributeNS ( Dom e, String uri, String qname, String value )
 2797       {
 2798           Locale l = e.locale();
 2799   
 2800           if (l.noSync())         { l.enter(); try { element_setAttributeNS( e, uri, qname, value ); } finally { l.exit(); } }
 2801           else synchronized ( l ) { l.enter(); try { element_setAttributeNS( e, uri, qname, value ); } finally { l.exit(); } }
 2802       }
 2803       
 2804       public static void element_setAttributeNS ( Dom e, String uri, String qname, String value )
 2805       {
 2806           validateQualifiedName( qname, uri, true );
 2807           
 2808           QName name = e.locale().makeQualifiedQName( uri, qname );
 2809           String local = name.getLocalPart();
 2810           String prefix = validatePrefix( name.getPrefix(), uri, local, true );
 2811   
 2812           Dom a = attributes_getNamedItemNS( e, uri, local );
 2813   
 2814           if (a == null)
 2815           {
 2816               a = document_createAttributeNS( node_getOwnerDocument( e ), uri, local );
 2817               attributes_setNamedItemNS( e, a );
 2818           }
 2819   
 2820           node_setPrefix( a, prefix );
 2821           node_setNodeValue( a, value );
 2822       }
 2823   
 2824       //////////////////////////////////////////////////////////////////////////////////////
 2825       //////////////////////////////////////////////////////////////////////////////////////
 2826       //////////////////////////////////////////////////////////////////////////////////////
 2827   
 2828       public static NodeList _element_getElementsByTagName ( Dom e, String name )
 2829       {
 2830           Locale l = e.locale();
 2831   
 2832           if (l.noSync())         { l.enter(); try { return element_getElementsByTagName( e, name ); } finally { l.exit(); } }
 2833           else synchronized ( l ) { l.enter(); try { return element_getElementsByTagName( e, name ); } finally { l.exit(); } }
 2834   
 2835       }
 2836       public static NodeList element_getElementsByTagName ( Dom e, String name )
 2837       {
 2838           return new ElementsByTagNameNodeList( e, name );
 2839       }
 2840   
 2841       //////////////////////////////////////////////////////////////////////////////////////
 2842       //////////////////////////////////////////////////////////////////////////////////////
 2843       //////////////////////////////////////////////////////////////////////////////////////
 2844   
 2845       public static NodeList _element_getElementsByTagNameNS ( Dom e, String uri, String local )
 2846       {
 2847           Locale l = e.locale();
 2848   
 2849           if (l.noSync())         { l.enter(); try { return element_getElementsByTagNameNS( e, uri, local ); } finally { l.exit(); } }
 2850           else synchronized ( l ) { l.enter(); try { return element_getElementsByTagNameNS( e, uri, local ); } finally { l.exit(); } }
 2851       }
 2852       
 2853       public static NodeList element_getElementsByTagNameNS ( Dom e, String uri, String local )
 2854       {
 2855           return new ElementsByTagNameNSNodeList( e, uri, local );
 2856       }
 2857       
 2858       //////////////////////////////////////////////////////////////////////////////////////
 2859       //////////////////////////////////////////////////////////////////////////////////////
 2860       //////////////////////////////////////////////////////////////////////////////////////
 2861   
 2862       public static int _attributes_getLength ( Dom e )
 2863       {
 2864           Locale l = e.locale();
 2865   
 2866           if (l.noSync())         { l.enter(); try { return attributes_getLength( e ); } finally { l.exit(); } }
 2867           else synchronized ( l ) { l.enter(); try { return attributes_getLength( e ); } finally { l.exit(); } }
 2868       }
 2869       
 2870       public static int attributes_getLength ( Dom e )
 2871       {
 2872           int n = 0;
 2873   
 2874           Cur c = e.tempCur();
 2875   
 2876           while ( c.toNextAttr() )
 2877               n++;
 2878   
 2879           c.release();
 2880   
 2881           return n;
 2882       }
 2883   
 2884       //////////////////////////////////////////////////////////////////////////////////////
 2885       //////////////////////////////////////////////////////////////////////////////////////
 2886       //////////////////////////////////////////////////////////////////////////////////////
 2887   
 2888       public static Node _attributes_setNamedItem ( Dom e, Node attr )
 2889       {
 2890           Locale l = e.locale();
 2891   
 2892           if (attr == null)
 2893               throw new IllegalArgumentException( "Attr to set is null" );
 2894   
 2895           Dom a;
 2896           
 2897           if (!(attr instanceof Dom) || (a = (Dom) attr).locale() != l)
 2898               throw new WrongDocumentErr( "Attr to set is from another document" );
 2899           
 2900           Dom oldA;
 2901   
 2902           if (l.noSync())         { l.enter(); try { oldA = attributes_setNamedItem( e, a ); } finally { l.exit(); } }
 2903           else synchronized ( l ) { l.enter(); try { oldA = attributes_setNamedItem( e, a ); } finally { l.exit(); } }
 2904   
 2905           return (Node) oldA;
 2906       }
 2907       
 2908       public static Dom attributes_setNamedItem ( Dom e, Dom a )
 2909       {
 2910           if (attr_getOwnerElement( a ) != null)
 2911               throw new InuseAttributeError();
 2912   
 2913           if (a.nodeType() != ATTR)
 2914               throw new HierarchyRequestErr( "Node is not an attribute" );
 2915   
 2916           String name = _node_getNodeName( a );
 2917           Dom oldAttr = null;
 2918   
 2919           Cur c = e.tempCur();
 2920   
 2921           while ( c.toNextAttr() )
 2922           {
 2923               Dom aa = c.getDom();
 2924   
 2925               if (_node_getNodeName( aa ).equals( name ))
 2926               {
 2927                   if (oldAttr == null)
 2928                       oldAttr = aa;
 2929                   else
 2930                   {
 2931                       removeNode( aa );
 2932                       c.toPrevAttr();
 2933                   }
 2934               }
 2935           }
 2936   
 2937           if (oldAttr == null)
 2938           {
 2939               c.moveToDom( e );
 2940               c.next();
 2941               Cur.moveNode( (Xobj) a, c );
 2942           }
 2943           else
 2944           {
 2945               c.moveToDom( oldAttr );
 2946               Cur.moveNode( (Xobj) a, c );
 2947               removeNode( oldAttr );
 2948           }
 2949   
 2950           c.release();
 2951           
 2952           return oldAttr;
 2953       }
 2954   
 2955       //////////////////////////////////////////////////////////////////////////////////////
 2956       //////////////////////////////////////////////////////////////////////////////////////
 2957       //////////////////////////////////////////////////////////////////////////////////////
 2958   
 2959       public static Node _attributes_getNamedItem ( Dom e, String name )
 2960       {
 2961           Locale l = e.locale();
 2962   
 2963           Dom n;
 2964   
 2965           if (l.noSync())         { l.enter(); try { n = attributes_getNamedItem( e, name ); } finally { l.exit(); } }
 2966           else synchronized ( l ) { l.enter(); try { n = attributes_getNamedItem( e, name ); } finally { l.exit(); } }
 2967   
 2968           return (Node) n;
 2969       }
 2970       
 2971       public static Dom attributes_getNamedItem ( Dom e, String name )
 2972       {
 2973           Dom a = null;
 2974   
 2975           Cur c = e.tempCur();
 2976   
 2977           while ( c.toNextAttr() )
 2978           {
 2979               Dom d = c.getDom();
 2980   
 2981               if (_node_getNodeName( d ).equals( name ))
 2982               {
 2983                   a = d;
 2984                   break;
 2985               }
 2986           }
 2987   
 2988           c.release();
 2989   
 2990           return a;
 2991       }
 2992       
 2993       //////////////////////////////////////////////////////////////////////////////////////
 2994       //////////////////////////////////////////////////////////////////////////////////////
 2995       //////////////////////////////////////////////////////////////////////////////////////
 2996   
 2997       public static Node _attributes_getNamedItemNS ( Dom e, String uri, String local )
 2998       {
 2999           Locale l = e.locale();
 3000   
 3001           Dom n;
 3002   
 3003           if (l.noSync())         { l.enter(); try { n = attributes_getNamedItemNS( e, uri, local ); } finally { l.exit(); } }
 3004           else synchronized ( l ) { l.enter(); try { n = attributes_getNamedItemNS( e, uri, local ); } finally { l.exit(); } }
 3005   
 3006           return (Node) n;
 3007       }
 3008       
 3009       public static Dom attributes_getNamedItemNS ( Dom e, String uri, String local )
 3010       {
 3011           if (uri == null)
 3012               uri = "";
 3013           
 3014           Dom a = null;
 3015   
 3016           Cur c = e.tempCur();
 3017   
 3018           while ( c.toNextAttr() )
 3019           {
 3020               Dom d = c.getDom();
 3021   
 3022               QName n = d.getQName();
 3023   
 3024               if (n.getNamespaceURI().equals( uri ) && n.getLocalPart().equals( local ))
 3025               {
 3026                   a = d;
 3027                   break;
 3028               }
 3029           }
 3030   
 3031           c.release();
 3032   
 3033           return a;
 3034       }
 3035       
 3036       //////////////////////////////////////////////////////////////////////////////////////
 3037       //////////////////////////////////////////////////////////////////////////////////////
 3038       //////////////////////////////////////////////////////////////////////////////////////
 3039   
 3040       public static Node _attributes_removeNamedItem ( Dom e, String name )
 3041       {
 3042           Locale l = e.locale();
 3043   
 3044           Dom n;
 3045   
 3046           if (l.noSync())         { l.enter(); try { n = attributes_removeNamedItem( e, name ); } finally { l.exit(); } }
 3047           else synchronized ( l ) { l.enter(); try { n = attributes_removeNamedItem( e, name ); } finally { l.exit(); } }
 3048   
 3049           return (Node) n;
 3050       }
 3051       
 3052       public static Dom attributes_removeNamedItem ( Dom e, String name )
 3053       {
 3054           Dom oldAttr = null;
 3055   
 3056           Cur c = e.tempCur();
 3057   
 3058           while ( c.toNextAttr() )
 3059           {
 3060               Dom aa = c.getDom();
 3061   
 3062               if (_node_getNodeName(aa).equals(name))
 3063               {
 3064                   if (oldAttr == null)
 3065                       oldAttr = aa;
 3066   
 3067                   if (((Xobj.AttrXobj) aa).isId())
 3068                   {
 3069                       Dom d = DomImpl.node_getOwnerDocument(aa);
 3070                       String val = node_getNodeValue( aa );
 3071                       if (d instanceof Xobj.DocumentXobj)
 3072                           ((Xobj.DocumentXobj) d).removeIdElement(val);
 3073                   }
 3074                   removeNode(aa);
 3075                   c.toPrevAttr();
 3076               }
 3077           }
 3078           
 3079           c.release();
 3080   
 3081           if (oldAttr == null)
 3082               throw new NotFoundErr( "Named item not found: " + name );
 3083   
 3084           return oldAttr;
 3085       }
 3086       
 3087       //////////////////////////////////////////////////////////////////////////////////////
 3088       //////////////////////////////////////////////////////////////////////////////////////
 3089       //////////////////////////////////////////////////////////////////////////////////////
 3090   
 3091       public static Node _attributes_removeNamedItemNS ( Dom e, String uri, String local )
 3092       {
 3093           Locale l = e.locale();
 3094   
 3095           Dom n;
 3096   
 3097           if (l.noSync())         { l.enter(); try { n = attributes_removeNamedItemNS( e, uri, local ); } finally { l.exit(); } }
 3098           else synchronized ( l ) { l.enter(); try { n = attributes_removeNamedItemNS( e, uri, local ); } finally { l.exit(); } }
 3099   
 3100           return (Node) n;
 3101       }
 3102       
 3103       public static Dom attributes_removeNamedItemNS ( Dom e, String uri, String local )
 3104       {
 3105           if (uri == null)
 3106               uri = "";
 3107           
 3108           Dom oldAttr = null;
 3109   
 3110           Cur c = e.tempCur();
 3111   
 3112           while ( c.toNextAttr() )
 3113           {
 3114               Dom aa = c.getDom();
 3115   
 3116               QName qn = aa.getQName();
 3117   
 3118               if (qn.getNamespaceURI().equals( uri ) && qn.getLocalPart().equals( local ))
 3119               {
 3120                   if (oldAttr == null)
 3121                       oldAttr = aa;
 3122                    if (((Xobj.AttrXobj) aa).isId())
 3123                    {
 3124                        Dom d = DomImpl.node_getOwnerDocument(aa);
 3125                        String val = node_getNodeValue( aa );
 3126                        if (d instanceof Xobj.DocumentXobj)
 3127                            ((Xobj.DocumentXobj) d).removeIdElement(val);
 3128                    }
 3129                   removeNode( aa );
 3130                   
 3131                   c.toPrevAttr();
 3132               }
 3133           }
 3134   
 3135           c.release();
 3136   
 3137           if (oldAttr == null)
 3138               throw new NotFoundErr( "Named item not found: uri=" + uri + ", local=" + local );
 3139   
 3140           return oldAttr;
 3141       }
 3142       
 3143       //////////////////////////////////////////////////////////////////////////////////////
 3144       //////////////////////////////////////////////////////////////////////////////////////
 3145       //////////////////////////////////////////////////////////////////////////////////////
 3146   
 3147       public static Node _attributes_setNamedItemNS ( Dom e, Node attr )
 3148       {
 3149           Locale l = e.locale();
 3150   
 3151           if (attr == null)
 3152               throw new IllegalArgumentException( "Attr to set is null" );
 3153   
 3154           Dom a;
 3155   
 3156           if (!(attr instanceof Dom) || (a = (Dom) attr).locale() != l)
 3157               throw new WrongDocumentErr( "Attr to set is from another document" );
 3158   
 3159           Dom oldA;
 3160   
 3161           if (l.noSync())         { l.enter(); try { oldA = attributes_setNamedItemNS( e, a ); } finally { l.exit(); } }
 3162           else synchronized ( l ) { l.enter(); try { oldA = attributes_setNamedItemNS( e, a ); } finally { l.exit(); } }
 3163   
 3164           return (Node) oldA;
 3165       }
 3166       
 3167       public static Dom attributes_setNamedItemNS ( Dom e, Dom a )
 3168       {
 3169           Dom owner = attr_getOwnerElement( a );
 3170   
 3171           if (owner == e)
 3172               return a;
 3173           
 3174           if (owner != null)
 3175               throw new InuseAttributeError();
 3176   
 3177           if (a.nodeType() != ATTR)
 3178               throw new HierarchyRequestErr( "Node is not an attribute" );
 3179   
 3180           QName name = a.getQName();
 3181           Dom oldAttr = null;
 3182   
 3183           Cur c = e.tempCur();
 3184   
 3185           while ( c.toNextAttr() )
 3186           {
 3187               Dom aa = c.getDom();
 3188   
 3189               if (aa.getQName().equals( name ))
 3190               {
 3191                   if (oldAttr == null)
 3192                       oldAttr = aa;
 3193                   else
 3194                   {
 3195                       removeNode( aa );
 3196                       c.toPrevAttr();
 3197                   }
 3198               }
 3199           }
 3200   
 3201           if (oldAttr == null)
 3202           {
 3203               c.moveToDom( e );
 3204               c.next();
 3205               Cur.moveNode( (Xobj) a, c );
 3206           }
 3207           else
 3208           {
 3209               c.moveToDom( oldAttr );
 3210               Cur.moveNode( (Xobj) a, c );
 3211               removeNode( oldAttr );
 3212           }
 3213   
 3214           c.release();
 3215   
 3216           return oldAttr;
 3217       }
 3218   
 3219       //////////////////////////////////////////////////////////////////////////////////////
 3220       //////////////////////////////////////////////////////////////////////////////////////
 3221       //////////////////////////////////////////////////////////////////////////////////////
 3222   
 3223       public static Node _attributes_item ( Dom e, int index )
 3224       {
 3225           Locale l = e.locale();
 3226   
 3227           Dom a;
 3228           
 3229           if (l.noSync())         { l.enter(); try { a = attributes_item( e, index ); } finally { l.exit(); } }
 3230           else synchronized ( l ) { l.enter(); try { a = attributes_item( e, index ); } finally { l.exit(); } }
 3231   
 3232           return (Node) a;
 3233       }
 3234       
 3235       public static Dom attributes_item ( Dom e, int index )
 3236       {
 3237           if (index < 0)
 3238               return null;
 3239           
 3240           Cur c = e.tempCur();
 3241   
 3242           Dom a = null;
 3243   
 3244           while ( c.toNextAttr() )
 3245           {
 3246               if (index-- == 0)
 3247               {
 3248                   a = c.getDom();
 3249                   break;
 3250               }
 3251           }
 3252   
 3253           c.release();
 3254   
 3255           return a;
 3256       }
 3257   
 3258       //////////////////////////////////////////////////////////////////////////////////////
 3259       //////////////////////////////////////////////////////////////////////////////////////
 3260       //////////////////////////////////////////////////////////////////////////////////////
 3261   
 3262       public static String _processingInstruction_getData ( Dom p )
 3263       {
 3264           return _node_getNodeValue( p );
 3265       }
 3266   
 3267       //////////////////////////////////////////////////////////////////////////////////////
 3268       //////////////////////////////////////////////////////////////////////////////////////
 3269       //////////////////////////////////////////////////////////////////////////////////////
 3270   
 3271       public static String _processingInstruction_getTarget ( Dom p )
 3272       {
 3273           return _node_getNodeName( p );
 3274       }
 3275   
 3276       //////////////////////////////////////////////////////////////////////////////////////
 3277       //////////////////////////////////////////////////////////////////////////////////////
 3278       //////////////////////////////////////////////////////////////////////////////////////
 3279   
 3280       public static void _processingInstruction_setData ( Dom p, String data )
 3281       {
 3282           _node_setNodeValue( p, data );
 3283       }
 3284   
 3285       //////////////////////////////////////////////////////////////////////////////////////
 3286       //////////////////////////////////////////////////////////////////////////////////////
 3287       //////////////////////////////////////////////////////////////////////////////////////
 3288   
 3289       public static boolean _attr_getSpecified ( Dom a )
 3290       {
 3291           // Can't tell the difference
 3292           return true;
 3293       }
 3294   
 3295       //////////////////////////////////////////////////////////////////////////////////////
 3296       //////////////////////////////////////////////////////////////////////////////////////
 3297       //////////////////////////////////////////////////////////////////////////////////////
 3298   
 3299       public static Element _attr_getOwnerElement ( Dom a )
 3300       {
 3301           Locale l = a.locale();
 3302   
 3303           Dom e;
 3304   
 3305           if (l.noSync())         { l.enter(); try { e = attr_getOwnerElement( a ); } finally { l.exit(); } }
 3306           else synchronized ( l ) { l.enter(); try { e = attr_getOwnerElement( a ); } finally { l.exit(); } }
 3307   
 3308           return (Element) e;
 3309       }
 3310   
 3311       public static Dom attr_getOwnerElement ( Dom n )
 3312       {
 3313           Cur c = n.tempCur();
 3314   
 3315           if (!c.toParentRaw())
 3316           {
 3317               c.release();
 3318               return null;
 3319           }
 3320   
 3321           Dom p = c.getDom();
 3322   
 3323           c.release();
 3324   
 3325           return p;
 3326       }
 3327   
 3328       //////////////////////////////////////////////////////////////////////////////////////
 3329       //////////////////////////////////////////////////////////////////////////////////////
 3330       //////////////////////////////////////////////////////////////////////////////////////
 3331   
 3332       public static void _characterData_appendData ( Dom cd, String arg )
 3333       {
 3334           // TODO - fix this *really* cheesy/bad/lousy perf impl
 3335           //        also fix all the funcitons which follow
 3336   
 3337           if (arg != null && arg.length() != 0)
 3338               _node_setNodeValue( cd, _node_getNodeValue( cd ) + arg );
 3339       }
 3340   
 3341       //////////////////////////////////////////////////////////////////////////////////////
 3342       //////////////////////////////////////////////////////////////////////////////////////
 3343       //////////////////////////////////////////////////////////////////////////////////////
 3344   
 3345       public static void _characterData_deleteData ( Dom c, int offset, int count )
 3346       {
 3347           String s = _characterData_getData( c );
 3348   
 3349           if (offset < 0 || offset > s.length() || count < 0)
 3350               throw new IndexSizeError();
 3351   
 3352           if (offset + count > s.length())
 3353               count = s.length() - offset;
 3354   
 3355           if (count > 0)
 3356               _characterData_setData( c, s.substring( 0, offset ) + s.substring( offset + count ) );
 3357       }
 3358   
 3359       //////////////////////////////////////////////////////////////////////////////////////
 3360       //////////////////////////////////////////////////////////////////////////////////////
 3361       //////////////////////////////////////////////////////////////////////////////////////
 3362   
 3363       public static String _characterData_getData ( Dom c )
 3364       {
 3365           return _node_getNodeValue( c );
 3366       }
 3367   
 3368       //////////////////////////////////////////////////////////////////////////////////////
 3369       //////////////////////////////////////////////////////////////////////////////////////
 3370       //////////////////////////////////////////////////////////////////////////////////////
 3371   
 3372       public static int _characterData_getLength ( Dom c )
 3373       {
 3374           return _characterData_getData( c ).length();
 3375       }
 3376   
 3377       //////////////////////////////////////////////////////////////////////////////////////
 3378       //////////////////////////////////////////////////////////////////////////////////////
 3379       //////////////////////////////////////////////////////////////////////////////////////
 3380   
 3381       public static void _characterData_insertData ( Dom c, int offset, String arg )
 3382       {
 3383           String s = _characterData_getData( c );
 3384           
 3385           if (offset < 0 || offset > s.length())
 3386               throw new IndexSizeError();
 3387   
 3388           if (arg != null && arg.length() > 0)
 3389               _characterData_setData( c, s.substring( 0, offset ) + arg + s.substring( offset ) );
 3390       }
 3391   
 3392       //////////////////////////////////////////////////////////////////////////////////////
 3393       //////////////////////////////////////////////////////////////////////////////////////
 3394       //////////////////////////////////////////////////////////////////////////////////////
 3395   
 3396       public static void _characterData_replaceData ( Dom c, int offset, int count, String arg )
 3397       {
 3398           String s = _characterData_getData( c );
 3399   
 3400           if (offset < 0 || offset > s.length() || count < 0)
 3401               throw new IndexSizeError();
 3402   
 3403           if (offset + count > s.length())
 3404               count = s.length() - offset;
 3405   
 3406           if (count > 0)
 3407           {
 3408               _characterData_setData(
 3409                   c, s.substring( 0, offset ) + (arg == null ? "" : arg)
 3410                       + s.substring( offset + count ) );
 3411           }
 3412       }
 3413   
 3414       //////////////////////////////////////////////////////////////////////////////////////
 3415       //////////////////////////////////////////////////////////////////////////////////////
 3416       //////////////////////////////////////////////////////////////////////////////////////
 3417   
 3418       public static void _characterData_setData ( Dom c, String data )
 3419       {
 3420           _node_setNodeValue( c, data );
 3421       }
 3422   
 3423       //////////////////////////////////////////////////////////////////////////////////////
 3424       //////////////////////////////////////////////////////////////////////////////////////
 3425       //////////////////////////////////////////////////////////////////////////////////////
 3426   
 3427       public static String _characterData_substringData ( Dom c, int offset, int count )
 3428       {
 3429           String s = _characterData_getData( c );
 3430   
 3431           if (offset < 0 || offset > s.length() || count < 0)
 3432               throw new IndexSizeError();
 3433   
 3434           if (offset + count > s.length())
 3435               count = s.length() - offset;
 3436   
 3437           return s.substring( offset, offset + count );
 3438       }
 3439   
 3440       //////////////////////////////////////////////////////////////////////////////////////
 3441       //////////////////////////////////////////////////////////////////////////////////////
 3442       //////////////////////////////////////////////////////////////////////////////////////
 3443   
 3444       public static Text _text_splitText ( Dom t, int offset )
 3445       {
 3446           assert t.nodeType() == TEXT;
 3447           
 3448           String s = _characterData_getData( t );
 3449   
 3450           if (offset < 0 || offset > s.length())
 3451               throw new IndexSizeError();
 3452   
 3453           _characterData_deleteData( t, offset, s.length() - offset );
 3454   
 3455           // Don't need to pass a doc here, any node will do..
 3456           
 3457           Dom t2 = (Dom) _document_createTextNode( t, s.substring( offset ) );
 3458   
 3459           Dom p = (Dom) _node_getParentNode( t );
 3460   
 3461           if (p != null)
 3462           {
 3463               _node_insertBefore( p, (Text) t2, _node_getNextSibling( t ) );
 3464               t.locale().invalidateDomCaches(p);
 3465           }
 3466           
 3467           return (Text) t2;
 3468       }
 3469       
 3470       //////////////////////////////////////////////////////////////////////////////////////
 3471       //////////////////////////////////////////////////////////////////////////////////////
 3472       //////////////////////////////////////////////////////////////////////////////////////
 3473       
 3474       public static String _text_getWholeText ( Dom t )
 3475       {
 3476           throw new RuntimeException( "DOM Level 3 Not implemented" );
 3477       }
 3478       
 3479       //////////////////////////////////////////////////////////////////////////////////////
 3480       //////////////////////////////////////////////////////////////////////////////////////
 3481       //////////////////////////////////////////////////////////////////////////////////////
 3482       
 3483       public static boolean _text_isElementContentWhitespace ( Dom t )
 3484       {
 3485           throw new RuntimeException( "DOM Level 3 Not implemented" );
 3486       }
 3487       
 3488       //////////////////////////////////////////////////////////////////////////////////////
 3489       //////////////////////////////////////////////////////////////////////////////////////
 3490       //////////////////////////////////////////////////////////////////////////////////////
 3491       
 3492       public static Text _text_replaceWholeText ( Dom t, String content )
 3493       {
 3494           throw new RuntimeException( "DOM Level 3 Not implemented" );
 3495       }
 3496   
 3497       //////////////////////////////////////////////////////////////////////////////////////
 3498       //////////////////////////////////////////////////////////////////////////////////////
 3499       //////////////////////////////////////////////////////////////////////////////////////
 3500       
 3501       public static XMLStreamReader _getXmlStreamReader ( Dom n )
 3502       {
 3503           Locale l = n.locale();
 3504   
 3505           if (l.noSync())         { l.enter(); try { return getXmlStreamReader( n ); } finally { l.exit(); } }
 3506           else synchronized ( l ) { l.enter(); try { return getXmlStreamReader( n ); } finally { l.exit(); } }
 3507       }
 3508       
 3509       public static XMLStreamReader getXmlStreamReader ( Dom n )
 3510       {
 3511           XMLStreamReader xs;
 3512           
 3513           switch ( n.nodeType() )
 3514           {
 3515           case DOCUMENT :
 3516           case DOCFRAG :
 3517           case ATTR :
 3518           case ELEMENT :
 3519           case PROCINST :
 3520           case COMMENT :
 3521           {
 3522               Cur c = n.tempCur();
 3523               xs = Jsr173.newXmlStreamReader( c, null );
 3524               c.release();
 3525               break;
 3526           }
 3527               
 3528           case TEXT :
 3529           case CDATA :
 3530           {
 3531               CharNode cn = (CharNode) n;
 3532   
 3533               Cur c;
 3534   
 3535               if ((c = cn.tempCur()) == null)
 3536               {
 3537                   c = n.locale().tempCur();
 3538                   
 3539                   xs = Jsr173.newXmlStreamReader( c, cn._src, cn._off, cn._cch );
 3540               }
 3541               else
 3542               {
 3543                   xs =
 3544                       Jsr173.newXmlStreamReader(
 3545                           c , c.getChars( cn._cch ), c._offSrc, c._cchSrc );
 3546                   
 3547               }
 3548   
 3549               c.release();
 3550               
 3551               break;
 3552           }
 3553               
 3554           case ENTITYREF :
 3555           case ENTITY :
 3556           case DOCTYPE :
 3557           case NOTATION :
 3558               throw new RuntimeException( "Not impl" );
 3559               
 3560           default : throw new RuntimeException( "Unknown kind" );
 3561           }
 3562   
 3563           return xs;
 3564       }
 3565       
 3566       //////////////////////////////////////////////////////////////////////////////////////
 3567       //////////////////////////////////////////////////////////////////////////////////////
 3568       //////////////////////////////////////////////////////////////////////////////////////
 3569   
 3570       public static XmlCursor _getXmlCursor ( Dom n )
 3571       {
 3572           Locale l = n.locale();
 3573   
 3574           if (l.noSync())         { l.enter(); try { return getXmlCursor( n ); } finally { l.exit(); } }
 3575           else synchronized ( l ) { l.enter(); try { return getXmlCursor( n ); } finally { l.exit(); } }
 3576       }
 3577   
 3578       public static XmlCursor getXmlCursor ( Dom n )
 3579       {
 3580           Cur c = n.tempCur();
 3581   
 3582           Cursor xc = new Cursor( c );
 3583   
 3584           c.release();
 3585   
 3586           return xc;
 3587       }
 3588   
 3589       //////////////////////////////////////////////////////////////////////////////////////
 3590       //////////////////////////////////////////////////////////////////////////////////////
 3591       //////////////////////////////////////////////////////////////////////////////////////
 3592   
 3593       public static XmlObject _getXmlObject ( Dom n )
 3594       {
 3595           Locale l = n.locale();
 3596   
 3597           if (l.noSync())         { l.enter(); try { return getXmlObject( n ); } finally { l.exit(); } }
 3598           else synchronized ( l ) { l.enter(); try { return getXmlObject( n ); } finally { l.exit(); } }
 3599       }
 3600   
 3601       public static XmlObject getXmlObject ( Dom n )
 3602       {
 3603           Cur c = n.tempCur();
 3604   
 3605           XmlObject x = c.getObject();
 3606   
 3607           c.release();
 3608   
 3609           return x;
 3610       }
 3611   
 3612       //////////////////////////////////////////////////////////////////////////////////////
 3613       //////////////////////////////////////////////////////////////////////////////////////
 3614       //////////////////////////////////////////////////////////////////////////////////////
 3615   
 3616       static abstract class CharNode implements Dom, Node, CharacterData
 3617       {
 3618           public CharNode ( Locale l )
 3619           {
 3620               assert l != null;
 3621               
 3622               _locale = l;
 3623           }
 3624           
 3625           public QName getQName ( )
 3626           {
 3627               return null;
 3628           }
 3629   
 3630           public Locale locale ( )
 3631           {
 3632               assert isValid();
 3633               
 3634               return _locale == null ? ((Dom) _src).locale() : _locale;
 3635           }
 3636   
 3637           public void setChars ( Object src, int off, int cch )
 3638           {
 3639               assert CharUtil.isValid( src, off, cch );
 3640               assert _locale != null || _src instanceof Dom;
 3641   
 3642               if (_locale == null)
 3643                   _locale = ((Dom) _src).locale();
 3644   
 3645               _src = src;
 3646               _off = off;
 3647               _cch = cch;
 3648           }
 3649   
 3650           public Dom getDom ( )
 3651           {
 3652               assert isValid();
 3653               
 3654               if (_src instanceof Dom)
 3655                   return (Dom) _src;
 3656   
 3657               return null;
 3658           }
 3659   
 3660           public void setDom ( Dom d )
 3661           {
 3662               assert d != null;
 3663               
 3664               _src = d;
 3665               _locale = null;
 3666           }
 3667   
 3668           public Cur tempCur ( )
 3669           {
 3670               assert isValid();
 3671   
 3672               if (!(_src instanceof Dom))
 3673                   return null;
 3674               
 3675               Cur c = locale().tempCur();
 3676               c.moveToCharNode( this );
 3677               
 3678               return c;
 3679           }
 3680   
 3681           private boolean isValid ( )
 3682           {
 3683               if (_src instanceof Dom)
 3684                   return _locale == null;
 3685   
 3686               if (_locale == null)
 3687                   return false;
 3688   
 3689               return true;
 3690           }
 3691   
 3692           public static boolean isOnList ( CharNode nodes, CharNode node )
 3693           {
 3694               assert node != null;
 3695               
 3696               for ( CharNode cn = nodes ; cn != null ; cn = cn._next )
 3697                   if (cn == node)
 3698                       return true;
 3699   
 3700               return false;
 3701           }
 3702   
 3703           public static CharNode remove ( CharNode nodes, CharNode node )
 3704           {
 3705               assert isOnList( nodes, node );
 3706               
 3707               if (nodes == node)
 3708                   nodes = node._next;
 3709               else
 3710                   node._prev._next = node._next;
 3711   
 3712               if (node._next != null)
 3713                   node._next._prev = node._prev;
 3714   
 3715               node._prev = node._next = null;
 3716   
 3717               return nodes;
 3718           }
 3719   
 3720           public static CharNode insertNode ( CharNode nodes, CharNode newNode, CharNode before )
 3721           {
 3722               assert !isOnList( nodes, newNode );
 3723               assert before == null || isOnList( nodes, before );
 3724               assert newNode != null;
 3725               assert newNode._prev == null && newNode._next == null;
 3726   
 3727               if (nodes == null)
 3728               {
 3729                   assert before == null;
 3730                   nodes = newNode;
 3731               }
 3732               else if (nodes == before)
 3733               {
 3734                   nodes._prev = newNode;
 3735                   newNode._next = nodes;
 3736                   nodes = newNode;
 3737               }
 3738               else
 3739               {
 3740                   CharNode n = nodes;
 3741   
 3742                   while ( n._next != before )
 3743                       n = n._next;
 3744   
 3745                   if ((newNode._next = n._next) != null)
 3746                       n._next._prev = newNode;
 3747   
 3748                   newNode._prev = n;
 3749                   n._next = newNode;
 3750               }
 3751   
 3752               return nodes;
 3753           }
 3754   
 3755           public static CharNode appendNode ( CharNode nodes, CharNode newNode )
 3756           {
 3757               return insertNode( nodes, newNode, null );
 3758           }
 3759   
 3760           public static CharNode appendNodes ( CharNode nodes, CharNode newNodes )
 3761           {
 3762               assert newNodes != null;
 3763               assert newNodes._prev == null;
 3764   
 3765               if (nodes == null)
 3766                   return newNodes;
 3767   
 3768               CharNode n = nodes;
 3769   
 3770               while ( n._next != null )
 3771                   n = n._next;
 3772   
 3773               n._next = newNodes;
 3774               newNodes._prev = n;
 3775   
 3776               return nodes;
 3777           }
 3778   
 3779           public static CharNode copyNodes ( CharNode nodes, Object newSrc )
 3780           {
 3781               CharNode newNodes = null;
 3782   
 3783               for ( CharNode n = null ; nodes != null ; nodes = nodes._next )
 3784               {
 3785                   CharNode newNode;
 3786   
 3787                   if (nodes instanceof TextNode)
 3788                       newNode = nodes.locale().createTextNode();
 3789                   else
 3790                       newNode = nodes.locale().createCdataNode();
 3791   
 3792                   // How to deal with entity refs??
 3793   
 3794                   newNode.setChars( newSrc, nodes._off, nodes._cch );
 3795   
 3796                   if (newNodes == null)
 3797                       newNodes = newNode;
 3798   
 3799                   if (n != null)
 3800                   {
 3801                       n._next = newNode;
 3802                       newNode._prev = n;
 3803                   }
 3804   
 3805                   n = newNode;
 3806               }
 3807   
 3808               return newNodes;
 3809           }
 3810   
 3811           public boolean nodeCanHavePrefixUri()
 3812           {
 3813               return false;
 3814           }
 3815   
 3816           public boolean isNodeAftertext()
 3817           {
 3818               assert _src instanceof Xobj :
 3819                   "this method is to only be used for nodes backed up by Xobjs";
 3820               Xobj src =(Xobj) _src;
 3821               return src._charNodesValue == null ? true :
 3822                   src._charNodesAfter == null ? false :
 3823                   CharNode.isOnList(src._charNodesAfter, this);
 3824           }
 3825           public void dump ( PrintStream o, Object ref )
 3826           {
 3827               if (_src instanceof Dom)
 3828                   ((Dom) _src).dump( o, ref );
 3829               else
 3830                   o.println( "Lonely CharNode: \"" + CharUtil.getString( _src, _off, _cch ) + "\"" );
 3831           }
 3832           
 3833           public void dump ( PrintStream o )
 3834           {
 3835               dump( o, (Object) this );
 3836           }
 3837   
 3838           public void dump ( )
 3839           {
 3840               dump( System.out );
 3841           }
 3842   
 3843           public Node appendChild ( Node newChild ) { return DomImpl._node_appendChild( this, newChild ); }
 3844           public Node cloneNode ( boolean deep ) { return DomImpl._node_cloneNode( this, deep ); }
 3845           public NamedNodeMap getAttributes ( ) { return null; }
 3846           public NodeList getChildNodes ( ) { return DomImpl._emptyNodeList; }
 3847           public Node getParentNode ( ) { return DomImpl._node_getParentNode( this ); }
 3848           public Node removeChild ( Node oldChild ) { return DomImpl._node_removeChild( this, oldChild ); }
 3849           public Node getFirstChild ( ) { return null; }
 3850           public Node getLastChild ( ) { return null; }
 3851           public String getLocalName ( ) { return DomImpl._node_getLocalName( this ); }
 3852           public String getNamespaceURI ( ) { return DomImpl._node_getNamespaceURI( this ); }
 3853           public Node getNextSibling ( ) { return DomImpl._node_getNextSibling( this ); }
 3854           public String getNodeName ( ) { return DomImpl._node_getNodeName( this ); }
 3855           public short getNodeType ( ) { return DomImpl._node_getNodeType( this ); }
 3856           public String getNodeValue ( ) { return DomImpl._node_getNodeValue( this ); }
 3857           public Document getOwnerDocument ( ) { return DomImpl._node_getOwnerDocument( this ); }
 3858           public String getPrefix ( ) { return DomImpl._node_getPrefix( this ); }
 3859           public Node getPreviousSibling ( ) { return DomImpl._node_getPreviousSibling( this ); }
 3860           public boolean hasAttributes ( ) { return false; }
 3861           public boolean hasChildNodes ( ) { return false; }
 3862           public Node insertBefore ( Node newChild, Node refChild ) { return DomImpl._node_insertBefore( this, newChild, refChild ); }
 3863           public boolean isSupported ( String feature, String version ) { return DomImpl._node_isSupported( this, feature, version ); }
 3864           public void normalize ( ) { DomImpl._node_normalize( this ); }
 3865           public Node replaceChild ( Node newChild, Node oldChild ) { return DomImpl._node_replaceChild( this, newChild, oldChild ); }
 3866           public void setNodeValue ( String nodeValue ) { DomImpl._node_setNodeValue( this, nodeValue ); }
 3867           public void setPrefix ( String prefix ) { DomImpl._node_setPrefix( this, prefix ); }
 3868   
 3869           // DOM Level 3
 3870           public Object getUserData ( String key ) { return DomImpl._node_getUserData( this, key ); }
 3871           public Object setUserData ( String key, Object data, UserDataHandler handler ) { return DomImpl._node_setUserData( this, key, data, handler ); }
 3872           public Object getFeature ( String feature, String version ) { return DomImpl._node_getFeature( this, feature, version ); }
 3873           public boolean isEqualNode ( Node arg ) { return DomImpl._node_isEqualNode( this, arg ); }
 3874           public boolean isSameNode ( Node arg ) { return DomImpl._node_isSameNode( this, arg ); }
 3875           public String lookupNamespaceURI ( String prefix ) { return DomImpl._node_lookupNamespaceURI( this, prefix ); }
 3876           public String lookupPrefix ( String namespaceURI ) { return DomImpl._node_lookupPrefix( this, namespaceURI ); }
 3877           public boolean isDefaultNamespace ( String namespaceURI ) { return DomImpl._node_isDefaultNamespace( this, namespaceURI ); }
 3878           public void setTextContent ( String textContent ) { DomImpl._node_setTextContent( this, textContent ); }
 3879           public String getTextContent ( ) { return DomImpl._node_getTextContent( this ); }
 3880           public short compareDocumentPosition ( Node other ) { return DomImpl._node_compareDocumentPosition( this, other ); }
 3881           public String getBaseURI ( ) { return DomImpl._node_getBaseURI( this ); }
 3882   
 3883           public void appendData ( String arg ) { DomImpl._characterData_appendData( this, arg ); }
 3884           public void deleteData ( int offset, int count ) { DomImpl._characterData_deleteData( this, offset, count ); }
 3885           public String getData ( ) { return DomImpl._characterData_getData( this ); }
 3886           public int getLength ( ) { return DomImpl._characterData_getLength( this ); }
 3887           public void insertData ( int offset, String arg ) { DomImpl._characterData_insertData( this, offset, arg ); }
 3888           public void replaceData ( int offset, int count, String arg ) { DomImpl._characterData_replaceData( this, offset, count, arg ); }
 3889           public void setData ( String data ) { DomImpl._characterData_setData( this, data ); }
 3890           public String substringData ( int offset, int count ) { return DomImpl._characterData_substringData( this, offset, count ); }
 3891   
 3892           private Locale _locale;
 3893   
 3894           CharNode _next;
 3895           CharNode _prev;
 3896   
 3897           private Object _src;
 3898           
 3899           int _off;
 3900           int _cch;
 3901       }
 3902       
 3903       static class TextNode extends CharNode implements Text
 3904       {
 3905           TextNode ( Locale l )
 3906           {
 3907               super( l );
 3908           }
 3909   
 3910           public int nodeType ( ) { return DomImpl.TEXT; }
 3911   
 3912           public String name ( ) { return "#text"; }
 3913   
 3914           public Text splitText ( int offset ) { return DomImpl._text_splitText ( this, offset ); }
 3915           public String getWholeText ( ) { return DomImpl._text_getWholeText( this ); }
 3916           public boolean isElementContentWhitespace ( ) { return DomImpl._text_isElementContentWhitespace( this ); }
 3917           public Text replaceWholeText ( String content ) { return DomImpl._text_replaceWholeText( this, content ); }
 3918       }
 3919   
 3920       static class CdataNode extends TextNode implements CDATASection
 3921       {
 3922           CdataNode ( Locale l )
 3923           {
 3924               super( l );
 3925           }
 3926   
 3927           public int nodeType ( ) { return DomImpl.CDATA; }
 3928   
 3929           public String name ( ) { return "#cdata-section"; }
 3930       }
 3931       
 3932       static class SaajTextNode extends TextNode implements org.apache.xmlbeans.impl.soap.Text
 3933       {
 3934           SaajTextNode ( Locale l )
 3935           {
 3936               super( l );
 3937           }
 3938   
 3939           public boolean isComment ( ) { return DomImpl._soapText_isComment( this ); }
 3940           
 3941           public void detachNode ( ) { DomImpl._soapNode_detachNode( this ); }
 3942           public void recycleNode ( ) { DomImpl._soapNode_recycleNode( this ); }
 3943           public String getValue ( ) { return DomImpl._soapNode_getValue( this ); }
 3944           public void setValue ( String value ) { DomImpl._soapNode_setValue( this, value ); }
 3945           public SOAPElement getParentElement ( ) { return DomImpl._soapNode_getParentElement( this ); }
 3946           public void setParentElement ( SOAPElement p ) { DomImpl._soapNode_setParentElement( this, p ); }
 3947       }
 3948       
 3949       static class SaajCdataNode extends CdataNode implements org.apache.xmlbeans.impl.soap.Text
 3950       {
 3951           public SaajCdataNode ( Locale l )
 3952           {
 3953               super( l );
 3954           }
 3955   
 3956           public boolean isComment ( ) { return DomImpl._soapText_isComment( this ); }
 3957           
 3958           public void detachNode ( ) { DomImpl._soapNode_detachNode( this ); }
 3959           public void recycleNode ( ) { DomImpl._soapNode_recycleNode( this ); }
 3960           public String getValue ( ) { return DomImpl._soapNode_getValue( this ); }
 3961           public void setValue ( String value ) { DomImpl._soapNode_setValue( this, value ); }
 3962           public SOAPElement getParentElement ( ) { return DomImpl._soapNode_getParentElement( this ); }
 3963           public void setParentElement ( SOAPElement p ) { DomImpl._soapNode_setParentElement( this, p ); }
 3964       }
 3965   
 3966       //
 3967       // Soap Text Node
 3968       //
 3969   
 3970       public static boolean _soapText_isComment ( Dom n )
 3971       {
 3972           Locale l = n.locale();
 3973   
 3974           org.apache.xmlbeans.impl.soap.Text text = (org.apache.xmlbeans.impl.soap.Text) n;
 3975   
 3976           if (l.noSync())         { l.enter(); try { return l._saaj.soapText_isComment( text ); } finally { l.exit(); } }
 3977           else synchronized ( l ) { l.enter(); try { return l._saaj.soapText_isComment( text ); } finally { l.exit(); } }
 3978       }
 3979       
 3980       //
 3981       // Soap Node
 3982       //
 3983       
 3984       public static void _soapNode_detachNode ( Dom n )
 3985       {
 3986           Locale l = n.locale();
 3987   
 3988           org.apache.xmlbeans.impl.soap.Node node = (org.apache.xmlbeans.impl.soap.Node) n;
 3989   
 3990           if (l.noSync())         { l.enter(); try { l._saaj.soapNode_detachNode( node ); } finally { l.exit(); } }
 3991           else synchronized ( l ) { l.enter(); try { l._saaj.soapNode_detachNode( node ); } finally { l.exit(); } }
 3992       }
 3993       
 3994       public static void _soapNode_recycleNode ( Dom n )
 3995       {
 3996           Locale l = n.locale();
 3997   
 3998           org.apache.xmlbeans.impl.soap.Node node = (org.apache.xmlbeans.impl.soap.Node) n;
 3999   
 4000           if (l.noSync())         { l.enter(); try { l._saaj.soapNode_recycleNode( node ); } finally { l.exit(); } }
 4001           else synchronized ( l ) { l.enter(); try { l._saaj.soapNode_recycleNode( node ); } finally { l.exit(); } }
 4002       }
 4003       
 4004       public static String _soapNode_getValue ( Dom n )
 4005       {
 4006           Locale l = n.locale();
 4007   
 4008           org.apache.xmlbeans.impl.soap.Node node = (org.apache.xmlbeans.impl.soap.Node) n;
 4009   
 4010           if (l.noSync())         { l.enter(); try { return l._saaj.soapNode_getValue( node ); } finally { l.exit(); } }
 4011           else synchronized ( l ) { l.enter(); try { return l._saaj.soapNode_getValue( node ); } finally { l.exit(); } }
 4012       }
 4013   
 4014       public static void _soapNode_setValue ( Dom n, String value )
 4015       {
 4016           Locale l = n.locale();
 4017   
 4018           org.apache.xmlbeans.impl.soap.Node node = (org.apache.xmlbeans.impl.soap.Node) n;
 4019   
 4020           if (l.noSync())         { l.enter(); try { l._saaj.soapNode_setValue( node, value ); } finally { l.exit(); } }
 4021           else synchronized ( l ) { l.enter(); try { l._saaj.soapNode_setValue( node, value ); } finally { l.exit(); } }
 4022       }
 4023   
 4024       public static SOAPElement _soapNode_getParentElement ( Dom n )
 4025       {
 4026           Locale l = n.locale();
 4027   
 4028           org.apache.xmlbeans.impl.soap.Node node = (org.apache.xmlbeans.impl.soap.Node) n;
 4029   
 4030           if (l.noSync())         { l.enter(); try { return l._saaj.soapNode_getParentElement( node ); } finally { l.exit(); } }
 4031           else synchronized ( l ) { l.enter(); try { return l._saaj.soapNode_getParentElement( node ); } finally { l.exit(); } }
 4032       }
 4033   
 4034       public static void _soapNode_setParentElement ( Dom n, SOAPElement p )
 4035       {
 4036           Locale l = n.locale();
 4037   
 4038           org.apache.xmlbeans.impl.soap.Node node = (org.apache.xmlbeans.impl.soap.Node) n;
 4039   
 4040           if (l.noSync())         { l.enter(); try { l._saaj.soapNode_setParentElement( node, p ); } finally { l.exit(); } }
 4041           else synchronized ( l ) { l.enter(); try { l._saaj.soapNode_setParentElement( node, p ); } finally { l.exit(); } }
 4042       }
 4043   
 4044       //
 4045       // Soap Element
 4046       //
 4047   
 4048       public static void _soapElement_removeContents ( Dom d )
 4049       {
 4050           Locale l = d.locale();
 4051   
 4052           SOAPElement se = (SOAPElement) d;
 4053   
 4054           if (l.noSync())         { l.enter(); try { l._saaj.soapElement_removeContents( se ); } finally { l.exit(); } }
 4055           else synchronized ( l ) { l.enter(); try { l._saaj.soapElement_removeContents( se ); } finally { l.exit(); } }
 4056       }
 4057       
 4058       public static String _soapElement_getEncodingStyle ( Dom d )
 4059       {
 4060           Locale l = d.locale();
 4061   
 4062           SOAPElement se = (SOAPElement) d;
 4063   
 4064           if (l.noSync())         { l.enter(); try { return l._saaj.soapElement_getEncodingStyle( se ); } finally { l.exit(); } }
 4065           else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_getEncodingStyle( se ); } finally { l.exit(); } }
 4066       }
 4067       
 4068       public static void _soapElement_setEncodingStyle ( Dom d, String encodingStyle )
 4069       {
 4070           Locale l = d.locale();
 4071   
 4072           SOAPElement se = (SOAPElement) d;
 4073   
 4074           if (l.noSync())         { l.enter(); try { l._saaj.soapElement_setEncodingStyle( se, encodingStyle ); } finally { l.exit(); } }
 4075           else synchronized ( l ) { l.enter(); try { l._saaj.soapElement_setEncodingStyle( se, encodingStyle ); } finally { l.exit(); } }
 4076       }
 4077       
 4078       public static boolean _soapElement_removeNamespaceDeclaration ( Dom d, String prefix )
 4079       {
 4080           Locale l = d.locale();
 4081   
 4082           SOAPElement se = (SOAPElement) d;
 4083   
 4084           if (l.noSync())         { l.enter(); try { return l._saaj.soapElement_removeNamespaceDeclaration( se, prefix ); } finally { l.exit(); } }
 4085           else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_removeNamespaceDeclaration( se, prefix ); } finally { l.exit(); } }
 4086       }
 4087       
 4088       public static Iterator _soapElement_getAllAttributes ( Dom d )
 4089       {
 4090           Locale l = d.locale();
 4091   
 4092           SOAPElement se = (SOAPElement) d;
 4093   
 4094           if (l.noSync())         { l.enter(); try { return l._saaj.soapElement_getAllAttributes( se ); } finally { l.exit(); } }
 4095           else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_getAllAttributes( se ); } finally { l.exit(); } }
 4096       }
 4097       
 4098       public static Iterator _soapElement_getChildElements ( Dom d )
 4099       {
 4100           Locale l = d.locale();
 4101   
 4102           SOAPElement se = (SOAPElement) d;
 4103   
 4104           if (l.noSync())         { l.enter(); try { return l._saaj.soapElement_getChildElements( se ); } finally { l.exit(); } }
 4105           else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_getChildElements( se ); } finally { l.exit(); } }
 4106       }
 4107       
 4108       public static Iterator _soapElement_getNamespacePrefixes ( Dom d )
 4109       {
 4110           Locale l = d.locale();
 4111   
 4112           SOAPElement se = (SOAPElement) d;
 4113   
 4114           if (l.noSync())         { l.enter(); try { return l._saaj.soapElement_getNamespacePrefixes( se ); } finally { l.exit(); } }
 4115           else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_getNamespacePrefixes( se ); } finally { l.exit(); } }
 4116       }
 4117       
 4118       public static SOAPElement _soapElement_addAttribute ( Dom d, Name name, String value ) throws SOAPException
 4119       {
 4120           Locale l = d.locale();
 4121   
 4122           SOAPElement se = (SOAPElement) d;
 4123   
 4124           if (l.noSync())         { l.enter(); try { return l._saaj.soapElement_addAttribute( se, name, value ); } finally { l.exit(); } }
 4125           else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_addAttribute( se, name, value ); } finally { l.exit(); } }
 4126       }
 4127       
 4128       public static SOAPElement _soapElement_addChildElement ( Dom d, SOAPElement oldChild ) throws SOAPException
 4129       {
 4130           Locale l = d.locale();
 4131   
 4132           SOAPElement se = (SOAPElement) d;
 4133   
 4134           if (l.noSync())         { l.enter(); try { return l._saaj.soapElement_addChildElement( se, oldChild ); } finally { l.exit(); } }
 4135           else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_addChildElement( se, oldChild ); } finally { l.exit(); } }
 4136       }
 4137       
 4138       public static SOAPElement _soapElement_addChildElement ( Dom d, Name name ) throws SOAPException
 4139       {
 4140           Locale l = d.locale();
 4141   
 4142           SOAPElement se = (SOAPElement) d;
 4143   
 4144           if (l.noSync())         { l.enter(); try { return l._saaj.soapElement_addChildElement( se, name ); } finally { l.exit(); } }
 4145           else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_addChildElement( se, name ); } finally { l.exit(); } }
 4146       }
 4147       
 4148       public static SOAPElement _soapElement_addChildElement ( Dom d, String localName ) throws SOAPException
 4149       {
 4150           Locale l = d.locale();
 4151   
 4152           SOAPElement se = (SOAPElement) d;
 4153   
 4154           if (l.noSync())         { l.enter(); try { return l._saaj.soapElement_addChildElement( se, localName ); } finally { l.exit(); } }
 4155           else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_addChildElement( se, localName ); } finally { l.exit(); } }
 4156       }
 4157       
 4158       public static SOAPElement _soapElement_addChildElement ( Dom d, String localName, String prefix ) throws SOAPException
 4159       {
 4160           Locale l = d.locale();
 4161   
 4162           SOAPElement se = (SOAPElement) d;
 4163   
 4164           if (l.noSync())         { l.enter(); try { return l._saaj.soapElement_addChildElement( se, localName, prefix ); } finally { l.exit(); } }
 4165           else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_addChildElement( se, localName, prefix ); } finally { l.exit(); } }
 4166       }
 4167       
 4168       public static SOAPElement _soapElement_addChildElement ( Dom d, String localName, String prefix, String uri ) throws SOAPException
 4169       {
 4170           Locale l = d.locale();
 4171   
 4172           SOAPElement se = (SOAPElement) d;
 4173   
 4174           if (l.noSync())         { l.enter(); try { return l._saaj.soapElement_addChildElement( se, localName, prefix, uri ); } finally { l.exit(); } }
 4175           else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_addChildElement( se, localName, prefix, uri ); } finally { l.exit(); } }
 4176       }
 4177       
 4178       public static SOAPElement _soapElement_addNamespaceDeclaration ( Dom d, String prefix, String uri )
 4179       {
 4180           Locale l = d.locale();
 4181   
 4182           SOAPElement se = (SOAPElement) d;
 4183   
 4184           if (l.noSync())         { l.enter(); try { return l._saaj.soapElement_addNamespaceDeclaration( se, prefix, uri ); } finally { l.exit(); } }
 4185           else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_addNamespaceDeclaration( se, prefix, uri ); } finally { l.exit(); } }
 4186       }
 4187       
 4188       public static SOAPElement _soapElement_addTextNode ( Dom d, String data )
 4189       {
 4190           Locale l = d.locale();
 4191   
 4192           SOAPElement se = (SOAPElement) d;
 4193   
 4194           if (l.noSync())         { l.enter(); try { return l._saaj.soapElement_addTextNode( se, data ); } finally { l.exit(); } }
 4195           else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_addTextNode( se, data ); } finally { l.exit(); } }
 4196       }
 4197       
 4198       public static String _soapElement_getAttributeValue ( Dom d, Name name )
 4199       {
 4200           Locale l = d.locale();
 4201   
 4202           SOAPElement se = (SOAPElement) d;
 4203   
 4204           if (l.noSync())         { l.enter(); try { return l._saaj.soapElement_getAttributeValue( se, name ); } finally { l.exit(); } }
 4205           else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_getAttributeValue( se, name ); } finally { l.exit(); } }
 4206       }
 4207       
 4208       public static Iterator _soapElement_getChildElements ( Dom d, Name name )
 4209       {
 4210           Locale l = d.locale();
 4211   
 4212           SOAPElement se = (SOAPElement) d;
 4213   
 4214           if (l.noSync())         { l.enter(); try { return l._saaj.soapElement_getChildElements( se, name ); } finally { l.exit(); } }
 4215           else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_getChildElements( se, name ); } finally { l.exit(); } }
 4216       }
 4217       
 4218       public static Name _soapElement_getElementName ( Dom d )
 4219       {
 4220           Locale l = d.locale();
 4221   
 4222           SOAPElement se = (SOAPElement) d;
 4223   
 4224           if (l.noSync())         { l.enter(); try { return l._saaj.soapElement_getElementName( se ); } finally { l.exit(); } }
 4225           else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_getElementName( se ); } finally { l.exit(); } }
 4226       }
 4227       
 4228       public static String _soapElement_getNamespaceURI ( Dom d, String prefix )
 4229       {
 4230           Locale l = d.locale();
 4231   
 4232           SOAPElement se = (SOAPElement) d;
 4233   
 4234           if (l.noSync())         { l.enter(); try { return l._saaj.soapElement_getNamespaceURI( se, prefix ); } finally { l.exit(); } }
 4235           else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_getNamespaceURI( se, prefix ); } finally { l.exit(); } }
 4236       }
 4237       
 4238       public static Iterator _soapElement_getVisibleNamespacePrefixes ( Dom d )
 4239       {
 4240           Locale l = d.locale();
 4241   
 4242           SOAPElement se = (SOAPElement) d;
 4243   
 4244           if (l.noSync())         { l.enter(); try { return l._saaj.soapElement_getVisibleNamespacePrefixes( se ); } finally { l.exit(); } }
 4245           else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_getVisibleNamespacePrefixes( se ); } finally { l.exit(); } }
 4246       }
 4247       
 4248       public static boolean _soapElement_removeAttribute ( Dom d, Name name )
 4249       {
 4250           Locale l = d.locale();
 4251   
 4252           SOAPElement se = (SOAPElement) d;
 4253   
 4254           if (l.noSync())         { l.enter(); try { return l._saaj.soapElement_removeAttribute( se, name ); } finally { l.exit(); } }
 4255           else synchronized ( l ) { l.enter(); try { return l._saaj.soapElement_removeAttribute( se, name ); } finally { l.exit(); } }
 4256       }
 4257   
 4258       //
 4259       // Soap Envelope
 4260       //
 4261   
 4262       public static SOAPBody _soapEnvelope_addBody ( Dom d ) throws SOAPException
 4263       {
 4264           Locale l = d.locale();
 4265   
 4266           SOAPEnvelope se = (SOAPEnvelope) d;
 4267   
 4268           if (l.noSync())         { l.enter(); try { return l._saaj.soapEnvelope_addBody( se ); } finally { l.exit(); } }
 4269           else synchronized ( l ) { l.enter(); try { return l._saaj.soapEnvelope_addBody( se ); } finally { l.exit(); } }
 4270       }
 4271       
 4272       public static SOAPBody _soapEnvelope_getBody ( Dom d ) throws SOAPException
 4273       {
 4274           Locale l = d.locale();
 4275   
 4276           SOAPEnvelope se = (SOAPEnvelope) d;
 4277   
 4278           if (l.noSync())         { l.enter(); try { return l._saaj.soapEnvelope_getBody( se ); } finally { l.exit(); } }
 4279           else synchronized ( l ) { l.enter(); try { return l._saaj.soapEnvelope_getBody( se ); } finally { l.exit(); } }
 4280       }
 4281       
 4282       public static SOAPHeader _soapEnvelope_getHeader ( Dom d ) throws SOAPException
 4283       {
 4284           Locale l = d.locale();
 4285   
 4286           SOAPEnvelope se = (SOAPEnvelope) d;
 4287   
 4288           if (l.noSync())         { l.enter(); try { return l._saaj.soapEnvelope_getHeader( se ); } finally { l.exit(); } }
 4289           else synchronized ( l ) { l.enter(); try { return l._saaj.soapEnvelope_getHeader( se ); } finally { l.exit(); } }
 4290       }
 4291       
 4292       public static SOAPHeader _soapEnvelope_addHeader ( Dom d ) throws SOAPException
 4293       {
 4294           Locale l = d.locale();
 4295   
 4296           SOAPEnvelope se = (SOAPEnvelope) d;
 4297   
 4298           if (l.noSync())         { l.enter(); try { return l._saaj.soapEnvelope_addHeader( se ); } finally { l.exit(); } }
 4299           else synchronized ( l ) { l.enter(); try { return l._saaj.soapEnvelope_addHeader( se ); } finally { l.exit(); } }
 4300       }
 4301       
 4302       public static Name _soapEnvelope_createName ( Dom d, String localName )
 4303       {
 4304           Locale l = d.locale();
 4305   
 4306           SOAPEnvelope se = (SOAPEnvelope) d;
 4307   
 4308           if (l.noSync())         { l.enter(); try { return l._saaj.soapEnvelope_createName( se, localName ); } finally { l.exit(); } }
 4309           else synchronized ( l ) { l.enter(); try { return l._saaj.soapEnvelope_createName( se, localName ); } finally { l.exit(); } }
 4310       }
 4311       
 4312       public static Name _soapEnvelope_createName ( Dom d, String localName, String prefix, String namespaceURI )
 4313       {
 4314           Locale l = d.locale();
 4315   
 4316           SOAPEnvelope se = (SOAPEnvelope) d;
 4317   
 4318           if (l.noSync())         { l.enter(); try { return l._saaj.soapEnvelope_createName( se, localName, prefix, namespaceURI ); } finally { l.exit(); } }
 4319           else synchronized ( l ) { l.enter(); try { return l._saaj.soapEnvelope_createName( se, localName, prefix, namespaceURI ); } finally { l.exit(); } }
 4320       }
 4321   
 4322       //
 4323       // Soap Header
 4324       //
 4325   
 4326       public static Iterator soapHeader_examineAllHeaderElements ( Dom d )
 4327       {
 4328           Locale l = d.locale();
 4329   
 4330           SOAPHeader sh = (SOAPHeader) d;
 4331   
 4332           if (l.noSync())         { l.enter(); try { return l._saaj.soapHeader_examineAllHeaderElements( sh ); } finally { l.exit(); } }
 4333           else synchronized ( l ) { l.enter(); try { return l._saaj.soapHeader_examineAllHeaderElements( sh ); } finally { l.exit(); } }
 4334       }
 4335   
 4336       public static Iterator soapHeader_extractAllHeaderElements ( Dom d )
 4337       {
 4338           Locale l = d.locale();
 4339   
 4340           SOAPHeader sh = (SOAPHeader) d;
 4341   
 4342           if (l.noSync())         { l.enter(); try { return l._saaj.soapHeader_extractAllHeaderElements( sh ); } finally { l.exit(); } }
 4343           else synchronized ( l ) { l.enter(); try { return l._saaj.soapHeader_extractAllHeaderElements( sh ); } finally { l.exit(); } }
 4344       }
 4345   
 4346       public static Iterator soapHeader_examineHeaderElements ( Dom d, String actor )
 4347       {
 4348           Locale l = d.locale();
 4349   
 4350           SOAPHeader sh = (SOAPHeader) d;
 4351   
 4352           if (l.noSync())         { l.enter(); try { return l._saaj.soapHeader_examineHeaderElements( sh, actor ); } finally { l.exit(); } }
 4353           else synchronized ( l ) { l.enter(); try { return l._saaj.soapHeader_examineHeaderElements( sh, actor ); } finally { l.exit(); } }
 4354       }
 4355   
 4356       public static Iterator soapHeader_examineMustUnderstandHeaderElements ( Dom d, String mustUnderstandString )
 4357       {
 4358           Locale l = d.locale();
 4359   
 4360           SOAPHeader sh = (SOAPHeader) d;
 4361   
 4362           if (l.noSync())         { l.enter(); try { return l._saaj.soapHeader_examineMustUnderstandHeaderElements( sh, mustUnderstandString ); } finally { l.exit(); } }
 4363           else synchronized ( l ) { l.enter(); try { return l._saaj.soapHeader_examineMustUnderstandHeaderElements( sh, mustUnderstandString ); } finally { l.exit(); } }
 4364       }
 4365   
 4366       public static Iterator soapHeader_extractHeaderElements ( Dom d, String actor )
 4367       {
 4368           Locale l = d.locale();
 4369   
 4370           SOAPHeader sh = (SOAPHeader) d;
 4371   
 4372           if (l.noSync())         { l.enter(); try { return l._saaj.soapHeader_extractHeaderElements( sh, actor ); } finally { l.exit(); } }
 4373           else synchronized ( l ) { l.enter(); try { return l._saaj.soapHeader_extractHeaderElements( sh, actor ); } finally { l.exit(); } }
 4374       }
 4375   
 4376       public static SOAPHeaderElement soapHeader_addHeaderElement ( Dom d, Name name )
 4377       {
 4378           Locale l = d.locale();
 4379   
 4380           SOAPHeader sh = (SOAPHeader) d;
 4381   
 4382           if (l.noSync())         { l.enter(); try { return l._saaj.soapHeader_addHeaderElement( sh, name ); } finally { l.exit(); } }
 4383           else synchronized ( l ) { l.enter(); try { return l._saaj.soapHeader_addHeaderElement( sh, name ); } finally { l.exit(); } }
 4384       }
 4385       
 4386       //
 4387       // Soap Body
 4388       //
 4389   
 4390       public static boolean soapBody_hasFault ( Dom d )
 4391       {
 4392           Locale l = d.locale();
 4393   
 4394           SOAPBody sb = (SOAPBody) d;
 4395   
 4396           if (l.noSync())         { l.enter(); try { return l._saaj.soapBody_hasFault( sb ); } finally { l.exit(); } }
 4397           else synchronized ( l ) { l.enter(); try { return l._saaj.soapBody_hasFault( sb ); } finally { l.exit(); } }
 4398       }
 4399       
 4400       public static SOAPFault soapBody_addFault ( Dom d ) throws SOAPException
 4401       {
 4402           Locale l = d.locale();
 4403   
 4404           SOAPBody sb = (SOAPBody) d;
 4405   
 4406           if (l.noSync())         { l.enter(); try { return l._saaj.soapBody_addFault( sb ); } finally { l.exit(); } }
 4407           else synchronized ( l ) { l.enter(); try { return l._saaj.soapBody_addFault( sb ); } finally { l.exit(); } }
 4408       }
 4409       
 4410       public static SOAPFault soapBody_getFault ( Dom d )
 4411       {
 4412           Locale l = d.locale();
 4413   
 4414           SOAPBody sb = (SOAPBody) d;
 4415   
 4416           if (l.noSync())         { l.enter(); try { return l._saaj.soapBody_getFault( sb ); } finally { l.exit(); } }
 4417           else synchronized ( l ) { l.enter(); try { return l._saaj.soapBody_getFault( sb ); } finally { l.exit(); } }
 4418       }
 4419       
 4420       public static SOAPBodyElement soapBody_addBodyElement ( Dom d, Name name )
 4421       {
 4422           Locale l = d.locale();
 4423   
 4424           SOAPBody sb = (SOAPBody) d;
 4425   
 4426           if (l.noSync())         { l.enter(); try { return l._saaj.soapBody_addBodyElement( sb, name ); } finally { l.exit(); } }
 4427           else synchronized ( l ) { l.enter(); try { return l._saaj.soapBody_addBodyElement( sb, name ); } finally { l.exit(); } }
 4428       }
 4429       
 4430       public static SOAPBodyElement soapBody_addDocument ( Dom d, Document document )
 4431       {
 4432           Locale l = d.locale();
 4433   
 4434           SOAPBody sb = (SOAPBody) d;
 4435   
 4436           if (l.noSync())         { l.enter(); try { return l._saaj.soapBody_addDocument( sb, document ); } finally { l.exit(); } }
 4437           else synchronized ( l ) { l.enter(); try { return l._saaj.soapBody_addDocument( sb, document ); } finally { l.exit(); } }
 4438       }
 4439       
 4440       public static SOAPFault soapBody_addFault ( Dom d, Name name, String s ) throws SOAPException
 4441       {
 4442           Locale l = d.locale();
 4443   
 4444           SOAPBody sb = (SOAPBody) d;
 4445   
 4446           if (l.noSync())         { l.enter(); try { return l._saaj.soapBody_addFault( sb, name, s ); } finally { l.exit(); } }
 4447           else synchronized ( l ) { l.enter(); try { return l._saaj.soapBody_addFault( sb, name, s ); } finally { l.exit(); } }
 4448       }
 4449       
 4450       public static SOAPFault soapBody_addFault ( Dom d, Name faultCode, String faultString, java.util.Locale locale ) throws SOAPException
 4451       {
 4452           Locale l = d.locale();
 4453   
 4454           SOAPBody sb = (SOAPBody) d;
 4455   
 4456           if (l.noSync())         { l.enter(); try { return l._saaj.soapBody_addFault( sb, faultCode, faultString, locale ); } finally { l.exit(); } }
 4457           else synchronized ( l ) { l.enter(); try { return l._saaj.soapBody_addFault( sb, faultCode, faultString, locale ); } finally { l.exit(); } }
 4458       }
 4459       
 4460       //
 4461       // Soap Fault
 4462       //
 4463   
 4464       public static void soapFault_setFaultString ( Dom d, String faultString )
 4465       {
 4466           Locale l = d.locale();
 4467   
 4468           SOAPFault sf = (SOAPFault) d;
 4469   
 4470           if (l.noSync())         { l.enter(); try { l._saaj.soapFault_setFaultString( sf, faultString ); } finally { l.exit(); } }
 4471           else synchronized ( l ) { l.enter(); try { l._saaj.soapFault_setFaultString( sf, faultString ); } finally { l.exit(); } }
 4472       }
 4473       
 4474       public static void soapFault_setFaultString ( Dom d, String faultString, java.util.Locale locale )
 4475       {
 4476           Locale l = d.locale();
 4477   
 4478           SOAPFault sf = (SOAPFault) d;
 4479   
 4480           if (l.noSync())         { l.enter(); try { l._saaj.soapFault_setFaultString( sf, faultString, locale ); } finally { l.exit(); } }
 4481           else synchronized ( l ) { l.enter(); try { l._saaj.soapFault_setFaultString( sf, faultString, locale ); } finally { l.exit(); } }
 4482       }
 4483       
 4484       public static void soapFault_setFaultCode ( Dom d, Name faultCodeName ) throws SOAPException
 4485       {
 4486           Locale l = d.locale();
 4487   
 4488           SOAPFault sf = (SOAPFault) d;
 4489   
 4490           if (l.noSync())         { l.enter(); try { l._saaj.soapFault_setFaultCode( sf, faultCodeName ); } finally { l.exit(); } }
 4491           else synchronized ( l ) { l.enter(); try { l._saaj.soapFault_setFaultCode( sf, faultCodeName ); } finally { l.exit(); } }
 4492       }
 4493       
 4494       public static void soapFault_setFaultActor ( Dom d, String faultActorString )
 4495       {
 4496           Locale l = d.locale();
 4497   
 4498           SOAPFault sf = (SOAPFault) d;
 4499   
 4500           if (l.noSync())         { l.enter(); try { l._saaj.soapFault_setFaultActor( sf, faultActorString ); } finally { l.exit(); } }
 4501           else synchronized ( l ) { l.enter(); try { l._saaj.soapFault_setFaultActor( sf, faultActorString ); } finally { l.exit(); } }
 4502       }
 4503       
 4504       public static String soapFault_getFaultActor ( Dom d )
 4505       {
 4506           Locale l = d.locale();
 4507   
 4508           SOAPFault sf = (SOAPFault) d;
 4509   
 4510           if (l.noSync())         { l.enter(); try { return l._saaj.soapFault_getFaultActor( sf ); } finally { l.exit(); } }
 4511           else synchronized ( l ) { l.enter(); try { return l._saaj.soapFault_getFaultActor( sf ); } finally { l.exit(); } }
 4512       }
 4513       
 4514       public static String soapFault_getFaultCode ( Dom d )
 4515       {
 4516           Locale l = d.locale();
 4517   
 4518           SOAPFault sf = (SOAPFault) d;
 4519   
 4520           if (l.noSync())         { l.enter(); try { return l._saaj.soapFault_getFaultCode( sf ); } finally { l.exit(); } }
 4521           else synchronized ( l ) { l.enter(); try { return l._saaj.soapFault_getFaultCode( sf ); } finally { l.exit(); } }
 4522       }
 4523       
 4524       public static void soapFault_setFaultCode ( Dom d, String faultCode ) throws SOAPException
 4525       {
 4526           Locale l = d.locale();
 4527   
 4528           SOAPFault sf = (SOAPFault) d;
 4529   
 4530           if (l.noSync())         { l.enter(); try { l._saaj.soapFault_setFaultCode( sf, faultCode ); } finally { l.exit(); } }
 4531           else synchronized ( l ) { l.enter(); try { l._saaj.soapFault_setFaultCode( sf, faultCode ); } finally { l.exit(); } }
 4532       }
 4533       
 4534       public static java.util.Locale soapFault_getFaultStringLocale ( Dom d )
 4535       {
 4536           Locale l = d.locale();
 4537   
 4538           SOAPFault sf = (SOAPFault) d;
 4539   
 4540           if (l.noSync())         { l.enter(); try { return l._saaj.soapFault_getFaultStringLocale( sf ); } finally { l.exit(); } }
 4541           else synchronized ( l ) { l.enter(); try { return l._saaj.soapFault_getFaultStringLocale( sf ); } finally { l.exit(); } }
 4542       }
 4543       
 4544       public static Name soapFault_getFaultCodeAsName ( Dom d )
 4545       {
 4546           Locale l = d.locale();
 4547   
 4548           SOAPFault sf = (SOAPFault) d;
 4549   
 4550           if (l.noSync())         { l.enter(); try { return l._saaj.soapFault_getFaultCodeAsName( sf ); } finally { l.exit(); } }
 4551           else synchronized ( l ) { l.enter(); try { return l._saaj.soapFault_getFaultCodeAsName( sf ); } finally { l.exit(); } }
 4552       }
 4553       
 4554       public static String soapFault_getFaultString ( Dom d )
 4555       {
 4556           Locale l = d.locale();
 4557   
 4558           SOAPFault sf = (SOAPFault) d;
 4559   
 4560           if (l.noSync())         { l.enter(); try { return l._saaj.soapFault_getFaultString( sf ); } finally { l.exit(); } }
 4561           else synchronized ( l ) { l.enter(); try { return l._saaj.soapFault_getFaultString( sf ); } finally { l.exit(); } }
 4562       }
 4563       
 4564       public static Detail soapFault_addDetail ( Dom d ) throws SOAPException
 4565       {
 4566           Locale l = d.locale();
 4567   
 4568           SOAPFault sf = (SOAPFault) d;
 4569   
 4570           if (l.noSync())         { l.enter(); try { return l._saaj.soapFault_addDetail( sf ); } finally { l.exit(); } }
 4571           else synchronized ( l ) { l.enter(); try { return l._saaj.soapFault_addDetail( sf ); } finally { l.exit(); } }
 4572       }
 4573       
 4574       public static Detail soapFault_getDetail ( Dom d )
 4575       {
 4576           Locale l = d.locale();
 4577   
 4578           SOAPFault sf = (SOAPFault) d;
 4579   
 4580           if (l.noSync())         { l.enter(); try { return l._saaj.soapFault_getDetail( sf ); } finally { l.exit(); } }
 4581           else synchronized ( l ) { l.enter(); try { return l._saaj.soapFault_getDetail( sf ); } finally { l.exit(); } }
 4582       }
 4583       
 4584       //
 4585       // Soap Header Element
 4586       //
 4587   
 4588       public static void soapHeaderElement_setMustUnderstand ( Dom d, boolean mustUnderstand )
 4589       {
 4590           Locale l = d.locale();
 4591   
 4592           SOAPHeaderElement she = (SOAPHeaderElement) d;
 4593   
 4594           if (l.noSync())         { l.enter(); try { l._saaj.soapHeaderElement_setMustUnderstand( she, mustUnderstand ); } finally { l.exit(); } }
 4595           else synchronized ( l ) { l.enter(); try { l._saaj.soapHeaderElement_setMustUnderstand( she, mustUnderstand ); } finally { l.exit(); } }
 4596       }
 4597       
 4598       public static boolean soapHeaderElement_getMustUnderstand ( Dom d )
 4599       {
 4600           Locale l = d.locale();
 4601   
 4602           SOAPHeaderElement she = (SOAPHeaderElement) d;
 4603   
 4604           if (l.noSync())         { l.enter(); try { return l._saaj.soapHeaderElement_getMustUnderstand( she ); } finally { l.exit(); } }
 4605           else synchronized ( l ) { l.enter(); try { return l._saaj.soapHeaderElement_getMustUnderstand( she ); } finally { l.exit(); } }
 4606       }
 4607       
 4608       public static void soapHeaderElement_setActor ( Dom d, String actor )
 4609       {
 4610           Locale l = d.locale();
 4611   
 4612           SOAPHeaderElement she = (SOAPHeaderElement) d;
 4613   
 4614           if (l.noSync())         { l.enter(); try { l._saaj.soapHeaderElement_setActor( she, actor ); } finally { l.exit(); } }
 4615           else synchronized ( l ) { l.enter(); try { l._saaj.soapHeaderElement_setActor( she, actor ); } finally { l.exit(); } }
 4616       }
 4617       
 4618       public static String soapHeaderElement_getActor ( Dom d )
 4619       {
 4620           Locale l = d.locale();
 4621   
 4622           SOAPHeaderElement she = (SOAPHeaderElement) d;
 4623   
 4624           if (l.noSync())         { l.enter(); try { return l._saaj.soapHeaderElement_getActor( she ); } finally { l.exit(); } }
 4625           else synchronized ( l ) { l.enter(); try { return l._saaj.soapHeaderElement_getActor( she ); } finally { l.exit(); } }
 4626       }
 4627       
 4628       //
 4629       // Soap Header Element
 4630       //
 4631   
 4632       public static DetailEntry detail_addDetailEntry ( Dom d, Name name )
 4633       {
 4634           Locale l = d.locale();
 4635   
 4636           Detail detail = (Detail) d;
 4637   
 4638           if (l.noSync())         { l.enter(); try { return l._saaj.detail_addDetailEntry( detail, name ); } finally { l.exit(); } }
 4639           else synchronized ( l ) { l.enter(); try { return l._saaj.detail_addDetailEntry( detail, name ); } finally { l.exit(); } }
 4640       }
 4641       
 4642       public static Iterator detail_getDetailEntries ( Dom d )
 4643       {
 4644           Locale l = d.locale();
 4645   
 4646           Detail detail = (Detail) d;
 4647   
 4648           if (l.noSync())         { l.enter(); try { return l._saaj.detail_getDetailEntries( detail ); } finally { l.exit(); } }
 4649           else synchronized ( l ) { l.enter(); try { return l._saaj.detail_getDetailEntries( detail ); } finally { l.exit(); } }
 4650       }
 4651       
 4652       //
 4653       // Soap Header Element
 4654       //
 4655   
 4656       public static void _soapPart_removeAllMimeHeaders ( Dom d )
 4657       {
 4658           Locale l = d.locale();
 4659   
 4660           SOAPPart sp = (SOAPPart) d;
 4661   
 4662           if (l.noSync())         { l.enter(); try { l._saaj.soapPart_removeAllMimeHeaders( sp ); } finally { l.exit(); } }
 4663           else synchronized ( l ) { l.enter(); try { l._saaj.soapPart_removeAllMimeHeaders( sp ); } finally { l.exit(); } }
 4664       }
 4665       
 4666       public static void _soapPart_removeMimeHeader ( Dom d, String name )
 4667       {
 4668           Locale l = d.locale();
 4669   
 4670           SOAPPart sp = (SOAPPart) d;
 4671   
 4672           if (l.noSync())         { l.enter(); try { l._saaj.soapPart_removeMimeHeader( sp, name ); } finally { l.exit(); } }
 4673           else synchronized ( l ) { l.enter(); try { l._saaj.soapPart_removeMimeHeader( sp, name ); } finally { l.exit(); } }
 4674       }
 4675       
 4676       public static Iterator _soapPart_getAllMimeHeaders ( Dom d )
 4677       {
 4678           Locale l = d.locale();
 4679   
 4680           SOAPPart sp = (SOAPPart) d;
 4681   
 4682           if (l.noSync())         { l.enter(); try { return l._saaj.soapPart_getAllMimeHeaders( sp ); } finally { l.exit(); } }
 4683           else synchronized ( l ) { l.enter(); try { return l._saaj.soapPart_getAllMimeHeaders( sp ); } finally { l.exit(); } }
 4684       }
 4685       
 4686       public static SOAPEnvelope _soapPart_getEnvelope ( Dom d )
 4687       {
 4688           Locale l = d.locale();
 4689   
 4690           SOAPPart sp = (SOAPPart) d;
 4691   
 4692           if (l.noSync())         { l.enter(); try { return l._saaj.soapPart_getEnvelope( sp ); } finally { l.exit(); } }
 4693           else synchronized ( l ) { l.enter(); try { return l._saaj.soapPart_getEnvelope( sp ); } finally { l.exit(); } }
 4694       }
 4695       
 4696       public static Source _soapPart_getContent ( Dom d )
 4697       {
 4698           Locale l = d.locale();
 4699   
 4700           SOAPPart sp = (SOAPPart) d;
 4701   
 4702           if (l.noSync())         { l.enter(); try { return l._saaj.soapPart_getContent( sp ); } finally { l.exit(); } }
 4703           else synchronized ( l ) { l.enter(); try { return l._saaj.soapPart_getContent( sp ); } finally { l.exit(); } }
 4704       }
 4705       
 4706       public static void _soapPart_setContent ( Dom d, Source source )
 4707       {
 4708           Locale l = d.locale();
 4709   
 4710           SOAPPart sp = (SOAPPart) d;
 4711   
 4712           if (l.noSync())         { l.enter(); try { l._saaj.soapPart_setContent( sp, source ); } finally { l.exit(); } }
 4713           else synchronized ( l ) { l.enter(); try { l._saaj.soapPart_setContent( sp, source ); } finally { l.exit(); } }
 4714       }
 4715       
 4716       public static String[] _soapPart_getMimeHeader ( Dom d, String name )
 4717       {
 4718           Locale l = d.locale();
 4719   
 4720           SOAPPart sp = (SOAPPart) d;
 4721   
 4722           if (l.noSync())         { l.enter(); try { return l._saaj.soapPart_getMimeHeader( sp, name ); } finally { l.exit(); } }
 4723           else synchronized ( l ) { l.enter(); try { return l._saaj.soapPart_getMimeHeader( sp, name ); } finally { l.exit(); } }
 4724       }
 4725       
 4726       public static void _soapPart_addMimeHeader ( Dom d, String name, String value )
 4727       {
 4728           Locale l = d.locale();
 4729   
 4730           SOAPPart sp = (SOAPPart) d;
 4731   
 4732           if (l.noSync())         { l.enter(); try { l._saaj.soapPart_addMimeHeader( sp, name, value ); } finally { l.exit(); } }
 4733           else synchronized ( l ) { l.enter(); try { l._saaj.soapPart_addMimeHeader( sp, name, value ); } finally { l.exit(); } }
 4734       }
 4735       
 4736       public static void _soapPart_setMimeHeader ( Dom d, String name, String value )
 4737       {
 4738           Locale l = d.locale();
 4739   
 4740           SOAPPart sp = (SOAPPart) d;
 4741   
 4742           if (l.noSync())         { l.enter(); try { l._saaj.soapPart_setMimeHeader( sp, name, value ); } finally { l.exit(); } }
 4743           else synchronized ( l ) { l.enter(); try { l._saaj.soapPart_setMimeHeader( sp, name, value ); } finally { l.exit(); } }
 4744       }
 4745       
 4746       public static Iterator _soapPart_getMatchingMimeHeaders ( Dom d, String[] names )
 4747       {
 4748           Locale l = d.locale();
 4749   
 4750           SOAPPart sp = (SOAPPart) d;
 4751   
 4752           if (l.noSync())         { l.enter(); try { return l._saaj.soapPart_getMatchingMimeHeaders( sp, names ); } finally { l.exit(); } }
 4753           else synchronized ( l ) { l.enter(); try { return l._saaj.soapPart_getMatchingMimeHeaders( sp, names ); } finally { l.exit(); } }
 4754       }
 4755       
 4756       public static Iterator _soapPart_getNonMatchingMimeHeaders ( Dom d, String[] names )
 4757       {
 4758           Locale l = d.locale();
 4759   
 4760           SOAPPart sp = (SOAPPart) d;
 4761   
 4762           if (l.noSync())         { l.enter(); try { return l._saaj.soapPart_getNonMatchingMimeHeaders( sp, names ); } finally { l.exit(); } }
 4763           else synchronized ( l ) { l.enter(); try { return l._saaj.soapPart_getNonMatchingMimeHeaders( sp, names ); } finally { l.exit(); } }
 4764       }
 4765   
 4766       //
 4767       // Saaj callback
 4768       //
 4769       
 4770       private static class SaajData
 4771       {
 4772           Object _obj;
 4773       }
 4774   
 4775       public static void saajCallback_setSaajData ( Dom d, Object o )
 4776       {
 4777           Locale l = d.locale();
 4778   
 4779           if (l.noSync())         { l.enter(); try { impl_saajCallback_setSaajData( d, o ); } finally { l.exit(); } }
 4780           else synchronized ( l ) { l.enter(); try { impl_saajCallback_setSaajData( d, o ); } finally { l.exit(); } }
 4781       }
 4782       
 4783       public static void impl_saajCallback_setSaajData ( Dom d, Object o )
 4784       {
 4785           Locale l = d.locale();
 4786   
 4787           Cur c = l.tempCur();
 4788   
 4789           c.moveToDom( d );
 4790   
 4791           SaajData sd = null;
 4792   
 4793           if (o != null)
 4794           {
 4795               sd = (SaajData) c.getBookmark( SaajData.class );
 4796   
 4797               if (sd == null)
 4798                   sd = new SaajData();
 4799   
 4800               sd._obj = o;
 4801           }
 4802           
 4803           c.setBookmark( SaajData.class, sd );
 4804   
 4805           c.release();
 4806       }
 4807   
 4808       public static Object saajCallback_getSaajData ( Dom d )
 4809       {
 4810           Locale l = d.locale();
 4811   
 4812           if (l.noSync())         { l.enter(); try { return impl_saajCallback_getSaajData( d ); } finally { l.exit(); } }
 4813           else synchronized ( l ) { l.enter(); try { return impl_saajCallback_getSaajData( d ); } finally { l.exit(); } }
 4814       }
 4815       
 4816       public static Object impl_saajCallback_getSaajData ( Dom d )
 4817       {
 4818           Locale l = d.locale();
 4819   
 4820           Cur c = l.tempCur();
 4821   
 4822           c.moveToDom( d );
 4823   
 4824           SaajData sd = (SaajData) c.getBookmark( SaajData.class );
 4825   
 4826           Object o = sd == null ? null : sd._obj;
 4827   
 4828           c.release();
 4829   
 4830           return o;
 4831       }
 4832   
 4833       public static Element saajCallback_createSoapElement ( Dom d, QName name, QName parentName )
 4834       {
 4835           Locale l = d.locale();
 4836   
 4837           Dom e;
 4838   
 4839           if (l.noSync())         { l.enter(); try { e = impl_saajCallback_createSoapElement( d, name, parentName ); } finally { l.exit(); } }
 4840           else synchronized ( l ) { l.enter(); try { e = impl_saajCallback_createSoapElement( d, name, parentName ); } finally { l.exit(); } }
 4841   
 4842           return (Element) e;
 4843       }
 4844       
 4845       public static Dom impl_saajCallback_createSoapElement ( Dom d, QName name, QName parentName )
 4846       {
 4847           Cur c = d.locale().tempCur();
 4848           
 4849           c.createElement( name, parentName );
 4850           
 4851           Dom e = c.getDom();
 4852           
 4853           c.release();
 4854           
 4855           return e;
 4856       }
 4857           
 4858       public static Element saajCallback_importSoapElement (
 4859           Dom d, Element elem, boolean deep, QName parentName )
 4860       {
 4861           Locale l = d.locale();
 4862   
 4863           Dom e;
 4864   
 4865           if (l.noSync())         { l.enter(); try { e = impl_saajCallback_importSoapElement( d, elem, deep, parentName ); } finally { l.exit(); } }
 4866           else synchronized ( l ) { l.enter(); try { e = impl_saajCallback_importSoapElement( d, elem, deep, parentName ); } finally { l.exit(); } }
 4867   
 4868           return (Element) e;
 4869       }
 4870       
 4871       public static Dom impl_saajCallback_importSoapElement (
 4872           Dom d, Element elem, boolean deep, QName parentName )
 4873       {
 4874           // TODO -- need to rewrite DomImpl.document_importNode to use an Xcur
 4875           // to create the new tree.  Then, I can pass the parentName to the new
 4876           // fcn and use it to create the correct root parent
 4877           
 4878           throw new RuntimeException( "Not impl" );
 4879       }
 4880   
 4881       
 4882       public static Text saajCallback_ensureSoapTextNode ( Dom d )
 4883       {
 4884           Locale l = d.locale();
 4885   
 4886           if (l.noSync())         { l.enter(); try { return impl_saajCallback_ensureSoapTextNode( d ); } finally { l.exit(); } }
 4887           else synchronized ( l ) { l.enter(); try { return impl_saajCallback_ensureSoapTextNode( d ); } finally { l.exit(); } }
 4888       }
 4889       
 4890       public static Text impl_saajCallback_ensureSoapTextNode ( Dom d )
 4891       {
 4892   //        if (!(d instanceof Text))
 4893   //        {
 4894   //            Xcur x = d.tempCur();
 4895   //
 4896   //            x.moveTo
 4897   //
 4898   //            x.release();
 4899   //        }
 4900   //        
 4901   //        return (Text) d;
 4902   
 4903           return null;
 4904       }
 4905       
 4906   }
 4907    

Save This Page
Home » xmlbeans-2.5.0-src » org.apache.xmlbeans.impl » store » [javadoc | source]