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 java.util.ArrayList;
   19   
   20   import java.io.PrintStream;
   21   
   22   import javax.xml.namespace.QName;
   23   
   24   import javax.xml.stream.XMLStreamReader;
   25   
   26   import org.apache.xmlbeans.xml.stream.XMLInputStream;
   27   
   28   import org.apache.xmlbeans.SchemaTypeLoader;
   29   import org.apache.xmlbeans.SchemaType;
   30   import org.apache.xmlbeans.XmlCursor;
   31   import org.apache.xmlbeans.XmlObject;
   32   import org.apache.xmlbeans.XmlOptions;
   33   import org.apache.xmlbeans.XmlDocumentProperties;
   34   
   35   import org.apache.xmlbeans.impl.common.XMLChar;
   36   import org.apache.xmlbeans.impl.common.GlobalLock;
   37   
   38   import java.util.Map;
   39   import java.util.Collection;
   40   
   41   import java.io.InputStream;
   42   import java.io.OutputStream;
   43   import java.io.Reader;
   44   import java.io.Writer;
   45   import java.io.File;
   46   import java.io.IOException;
   47   import java.io.FileOutputStream;
   48   
   49   import org.w3c.dom.Node;
   50   
   51   import org.xml.sax.ContentHandler;
   52   import org.xml.sax.ext.LexicalHandler;
   53   import org.xml.sax.SAXException;
   54   
   55   import org.apache.xmlbeans.impl.store.Saver.TextSaver;
   56   import org.apache.xmlbeans.impl.store.Locale.ChangeListener;
   57   import org.apache.xmlbeans.impl.store.Path.PathEngine;
   58   
   59   public final class Cursor implements XmlCursor, ChangeListener {
   60       static final int ROOT = Cur.ROOT;
   61       static final int ELEM = Cur.ELEM;
   62       static final int ATTR = Cur.ATTR;
   63       static final int COMMENT = Cur.COMMENT;
   64       static final int PROCINST = Cur.PROCINST;
   65       static final int TEXT = Cur.TEXT;
   66   
   67       Cursor(Xobj x, int p) {
   68           _cur = x._locale.weakCur(this);
   69           _cur.moveTo(x, p);
   70           _currentSelection = -1;
   71       }
   72   
   73       Cursor(Cur c) {
   74           this(c._xobj, c._pos);
   75       }
   76   
   77       private static boolean isValid(Cur c) {
   78           if (c.kind() <= 0) {
   79               c.push();
   80   
   81               if (c.toParentRaw()) {
   82                   int pk = c.kind();
   83   
   84                   if (pk == COMMENT || pk == PROCINST || pk == ATTR)
   85                       return false;
   86               }
   87   
   88               c.pop();
   89           }
   90   
   91           return true;
   92       }
   93   
   94       private boolean isValid() {
   95           return isValid(_cur);
   96       }
   97   
   98       Locale locale() {
   99           return _cur._locale;
  100       }
  101   
  102       Cur tempCur() {
  103           return _cur.tempCur();
  104       }
  105   
  106       public void dump(PrintStream o) {
  107           _cur.dump(o);
  108       }
  109   
  110       static void validateLocalName(QName name) {
  111           if (name == null)
  112               throw new IllegalArgumentException("QName is null");
  113   
  114           validateLocalName(name.getLocalPart());
  115       }
  116   
  117       static void validateLocalName(String name) {
  118           if (name == null)
  119               throw new IllegalArgumentException("Name is null");
  120   
  121           if (name.length() == 0)
  122               throw new IllegalArgumentException("Name is empty");
  123   
  124           if (!XMLChar.isValidNCName(name))
  125               throw new IllegalArgumentException("Name is not valid");
  126       }
  127   
  128       static void validatePrefix(String name) {
  129           if (name == null)
  130               throw new IllegalArgumentException("Prefix is null");
  131   
  132           if (name.length() == 0)
  133               throw new IllegalArgumentException("Prefix is empty");
  134   
  135           if (Locale.beginsWithXml(name))
  136               throw new IllegalArgumentException("Prefix begins with 'xml'");
  137   
  138           if (!XMLChar.isValidNCName(name))
  139               throw new IllegalArgumentException("Prefix is not valid");
  140       }
  141   
  142       private static void complain(String msg) {
  143           throw new IllegalArgumentException(msg);
  144       }
  145   
  146       private void checkInsertionValidity(Cur that) {
  147           int thatKind = that.kind();
  148   
  149           if (thatKind < 0)
  150               complain("Can't move/copy/insert an end token.");
  151   
  152           if (thatKind == ROOT)
  153               complain("Can't move/copy/insert a whole document.");
  154   
  155           int thisKind = _cur.kind();
  156   
  157           if (thisKind == ROOT)
  158               complain("Can't insert before the start of the document.");
  159   
  160           if (thatKind == ATTR) {
  161               _cur.push();
  162               _cur.prevWithAttrs();
  163               int pk = _cur.kind();
  164               _cur.pop();
  165   
  166               if (pk != ELEM && pk != ROOT && pk != -ATTR) {
  167                   complain("Can only insert attributes before other attributes or after containers.");
  168               }
  169           }
  170   
  171           if (thisKind == ATTR && thatKind != ATTR)
  172               complain("Can only insert attributes before other attributes or after containers.");
  173       }
  174   
  175       private void insertNode(Cur that, String text) {
  176           assert !that.isRoot();
  177           assert that.isNode();
  178           assert isValid(that);
  179           assert isValid();
  180   
  181           if (text != null && text.length() > 0) {
  182               that.next();
  183               that.insertString(text);
  184               that.toParent();
  185           }
  186   
  187           checkInsertionValidity(that);
  188   
  189           that.moveNode(_cur);
  190   
  191           _cur.toEnd();
  192           _cur.nextWithAttrs();
  193       }
  194       
  195       //
  196       //
  197       //
  198   
  199       // TODO - deal with cursors moving to other documents upon release?
  200       // Can I move the ref from one q to another?  If not I will have to
  201       // change from a phantom ref to a soft/weak ref so I can know what
  202       // to do when I dequeue from the old q.
  203       
  204       public void _dispose() {
  205           _cur.release();
  206           _cur = null;
  207       }
  208   
  209       public XmlCursor _newCursor() {
  210           return new Cursor(_cur);
  211       }
  212   
  213       public QName _getName() {
  214           // TODO - consider taking this out of the gateway
  215           
  216           switch (_cur.kind()) {
  217               case ATTR:
  218   
  219                   if (_cur.isXmlns()) {
  220                       return
  221                               _cur._locale.makeQNameNoCheck(_cur.getXmlnsUri(), _cur.getXmlnsPrefix());
  222                   }
  223   
  224                   // Fall thru
  225                   
  226               case ELEM:
  227               case PROCINST:
  228                   return _cur.getName();
  229           }
  230   
  231           return null;
  232       }
  233   
  234       public void _setName(QName name) {
  235           if (name == null)
  236               throw new IllegalArgumentException("Name is null");
  237   
  238           switch (_cur.kind()) {
  239               case ELEM:
  240               case ATTR:
  241                   {
  242                       validateLocalName(name.getLocalPart());
  243                       break;
  244                   }
  245   
  246               case PROCINST:
  247                   {
  248                       validatePrefix(name.getLocalPart());
  249   
  250                       if (name.getNamespaceURI().length() > 0)
  251                           throw new IllegalArgumentException("Procinst name must have no URI");
  252   
  253                       if (name.getPrefix().length() > 0)
  254                           throw new IllegalArgumentException("Procinst name must have no prefix");
  255   
  256                       break;
  257                   }
  258   
  259               default :
  260                   throw
  261                           new IllegalStateException("Can set name on element, atrtribute and procinst only");
  262           }
  263   
  264           _cur.setName(name);
  265       }
  266   
  267       public TokenType _currentTokenType() {
  268           assert isValid();
  269   
  270           switch (_cur.kind()) {
  271               case ROOT:
  272                   return TokenType.STARTDOC;
  273               case -ROOT:
  274                   return TokenType.ENDDOC;
  275               case ELEM:
  276                   return TokenType.START;
  277               case -ELEM:
  278                   return TokenType.END;
  279               case TEXT:
  280                   return TokenType.TEXT;
  281               case ATTR:
  282                   return _cur.isXmlns() ? TokenType.NAMESPACE : TokenType.ATTR;
  283               case COMMENT:
  284                   return TokenType.COMMENT;
  285               case PROCINST:
  286                   return TokenType.PROCINST;
  287   
  288               default :
  289                   throw new IllegalStateException();
  290           }
  291       }
  292   
  293       public boolean _isStartdoc() {
  294           //return _currentTokenType().isStartdoc();
  295           assert isValid();
  296           return _cur.isRoot();
  297       }
  298   
  299       public boolean _isEnddoc() {
  300           //return _currentTokenType().isEnddoc();
  301           assert isValid();
  302           return _cur.isEndRoot();
  303       }
  304   
  305       public boolean _isStart() {
  306           //return _currentTokenType().isStart();
  307           assert isValid();
  308           return _cur.isElem();
  309       }
  310   
  311       public boolean _isEnd() {
  312           //return _currentTokenType().isEnd();
  313           assert isValid();
  314           return _cur.isEnd();
  315       }
  316   
  317       public boolean _isText() {
  318           //return _currentTokenType().isText();
  319           assert isValid();
  320           return _cur.isText();
  321       }
  322   
  323       public boolean _isAttr() {
  324           //return _currentTokenType().isAttr();
  325           assert isValid();
  326           return _cur.isNormalAttr();
  327       }
  328   
  329       public boolean _isNamespace() {
  330           //return _currentTokenType().isNamespace();
  331           assert isValid();
  332           return _cur.isXmlns();
  333       }
  334   
  335       public boolean _isComment() {
  336           //return _currentTokenType().isComment();
  337           assert isValid();
  338           return _cur.isComment();
  339       }
  340   
  341       public boolean _isProcinst() {
  342           //return _currentTokenType().isProcinst();
  343           assert isValid();
  344           return _cur.isProcinst();
  345       }
  346   
  347       public boolean _isContainer() {
  348           //return _currentTokenType().isContainer();
  349           assert isValid();
  350           return _cur.isContainer();
  351       }
  352   
  353       public boolean _isFinish() {
  354           //return _currentTokenType().isFinish();
  355           assert isValid();
  356           return _cur.isFinish();
  357       }
  358   
  359       public boolean _isAnyAttr() {
  360           //return _currentTokenType().isAnyAttr();
  361           assert isValid();
  362           return _cur.isAttr();
  363       }
  364   
  365       public TokenType _toNextToken() {
  366           assert isValid();
  367   
  368           switch (_cur.kind()) {
  369               case ROOT:
  370               case ELEM:
  371                   {
  372                       if (!_cur.toFirstAttr())
  373                           _cur.next();
  374   
  375                       break;
  376                   }
  377   
  378               case ATTR:
  379                   {
  380                       if (!_cur.toNextSibling()) {
  381                           _cur.toParent();
  382                           _cur.next();
  383                       }
  384   
  385                       break;
  386                   }
  387   
  388               case COMMENT:
  389               case PROCINST:
  390                   {
  391                       _cur.skip();
  392                       break;
  393                   }
  394   
  395               default :
  396                   {
  397                       if (!_cur.next())
  398                           return TokenType.NONE;
  399   
  400                       break;
  401                   }
  402           }
  403   
  404           return _currentTokenType();
  405       }
  406   
  407       public TokenType _toPrevToken() {
  408           assert isValid();
  409   
  410           // This method is different than the Cur version of prev in a few ways.  First,
  411           // Cursor iterates over attrs inline with all the other content.  Cur will skip attrs, or
  412           // if the Cur in in attrs, it will not jump out of attrs.  Also, if moving backwards and
  413           // text is to the left and right, Cur will move to the beginning of that text, while
  414           // Cursor will move further so that the token type to the right is not text.
  415           
  416           boolean wasText = _cur.isText();
  417   
  418           if (!_cur.prev()) {
  419               assert _cur.isRoot() || _cur.isAttr();
  420   
  421               if (_cur.isRoot())
  422                   return TokenType.NONE;
  423   
  424               _cur.toParent();
  425           } else {
  426               int k = _cur.kind();
  427   
  428               if (k < 0 && (k == -COMMENT || k == -PROCINST || k == -ATTR))
  429                   _cur.toParent();
  430               else if (_cur.isContainer())
  431                   _cur.toLastAttr();
  432               else if (wasText && _cur.isText())
  433                   return _toPrevToken();
  434           }
  435   
  436           return _currentTokenType();
  437       }
  438   
  439       public Object _monitor() {
  440           // TODO - some of these methods need not be protected by a
  441           // gatway.  This is one of them.  Inline this.
  442   
  443           return _cur._locale;
  444       }
  445   
  446       public boolean _toParent() {
  447           Cur c = _cur.tempCur();
  448   
  449           if (!c.toParent())
  450               return false;
  451   
  452           _cur.moveToCur(c);
  453   
  454           c.release();
  455   
  456           return true;
  457       }
  458   
  459       private static final class ChangeStampImpl implements ChangeStamp {
  460           ChangeStampImpl(Locale l) {
  461               _locale = l;
  462               _versionStamp = _locale.version();
  463           }
  464   
  465           public boolean hasChanged() {
  466               return _versionStamp != _locale.version();
  467           }
  468   
  469           private final Locale _locale;
  470           private final long _versionStamp;
  471       }
  472   
  473       public ChangeStamp _getDocChangeStamp() {
  474           return new ChangeStampImpl(_cur._locale);
  475       }
  476   
  477       //
  478       // These simply delegate to the version of the method which takes XmlOptions
  479       //
  480   
  481       /**
  482        * @deprecated XMLInputStream was deprecated by XMLStreamReader from STaX - jsr173 API.
  483        */
  484       public XMLInputStream _newXMLInputStream() {
  485           return _newXMLInputStream(null);
  486       }
  487   
  488       public XMLStreamReader _newXMLStreamReader() {
  489           return _newXMLStreamReader(null);
  490       }
  491   
  492       public Node _newDomNode() {
  493           return _newDomNode(null);
  494       }
  495   
  496       public InputStream _newInputStream() {
  497           return _newInputStream(null);
  498       }
  499   
  500       public String _xmlText() {
  501           return _xmlText(null);
  502       }
  503   
  504       public Reader _newReader() {
  505           return _newReader(null);
  506       }
  507   
  508       public void _save(File file) throws IOException {
  509           _save(file, null);
  510       }
  511   
  512       public void _save(OutputStream os) throws IOException {
  513           _save(os, null);
  514       }
  515   
  516       public void _save(Writer w) throws IOException {
  517           _save(w, null);
  518       }
  519   
  520       public void _save(ContentHandler ch, LexicalHandler lh) throws SAXException {
  521           _save(ch, lh, null);
  522       }
  523   
  524       //
  525       //
  526       //
  527   
  528       public XmlDocumentProperties _documentProperties() {
  529           return Locale.getDocProps(_cur, true);
  530       }
  531   
  532       public XMLStreamReader _newXMLStreamReader(XmlOptions options) {
  533           return Jsr173.newXmlStreamReader(_cur, options);
  534       }
  535   
  536       /**
  537        * @deprecated XMLInputStream was deprecated by XMLStreamReader from STaX - jsr173 API.
  538        */
  539       public XMLInputStream _newXMLInputStream(XmlOptions options) {
  540           return new Saver.XmlInputStreamImpl(_cur, options);
  541       }
  542   
  543       public String _xmlText(XmlOptions options) {
  544           assert isValid();
  545   
  546           return new TextSaver(_cur, options, null).saveToString();
  547       }
  548   
  549       public InputStream _newInputStream(XmlOptions options) {
  550           return new Saver.InputStreamSaver(_cur, options);
  551       }
  552   
  553       public Reader _newReader(XmlOptions options) {
  554           return new Saver.TextReader(_cur, options);
  555       }
  556   
  557       public void _save(ContentHandler ch, LexicalHandler lh, XmlOptions options)
  558               throws SAXException {
  559           new Saver.SaxSaver(_cur, options, ch, lh);
  560       }
  561   
  562       public void _save(File file, XmlOptions options) throws IOException {
  563           if (file == null)
  564               throw new IllegalArgumentException("Null file specified");
  565   
  566           OutputStream os = new FileOutputStream(file);
  567   
  568           try {
  569               _save(os, options);
  570           } finally {
  571               os.close();
  572           }
  573       }
  574   
  575       public void _save(OutputStream os, XmlOptions options) throws IOException {
  576           if (os == null)
  577               throw new IllegalArgumentException("Null OutputStream specified");
  578   
  579           InputStream is = _newInputStream(options);
  580   
  581           try {
  582               byte[] bytes = new byte[8192];
  583   
  584               for (; ;) {
  585                   int n = is.read(bytes);
  586   
  587                   if (n < 0)
  588                       break;
  589   
  590                   os.write(bytes, 0, n);
  591               }
  592           } finally {
  593               is.close();
  594           }
  595       }
  596   
  597       public void _save(Writer w, XmlOptions options) throws IOException {
  598           if (w == null)
  599               throw new IllegalArgumentException("Null Writer specified");
  600   
  601           if (options != null && options.hasOption( XmlOptions.SAVE_OPTIMIZE_FOR_SPEED ))
  602           {
  603               Saver.OptimizedForSpeedSaver.save(_cur, w); //ignore all other options
  604               return;
  605           }
  606   
  607           Reader r = _newReader(options);
  608   
  609           try {
  610               char[] chars = new char[8192];
  611   
  612               for (; ;) {
  613                   int n = r.read(chars);
  614   
  615                   if (n < 0)
  616                       break;
  617   
  618                   w.write(chars, 0, n);
  619               }
  620           } finally {
  621               r.close();
  622           }
  623       }
  624   
  625       public Node _getDomNode() {
  626           return (Node) _cur.getDom();
  627       }
  628   
  629       private boolean isDomFragment() {
  630           if (!isStartdoc())
  631               return true;
  632   
  633           boolean seenElement = false;
  634   
  635           XmlCursor c = newCursor();
  636           int token = c.toNextToken().intValue();
  637   
  638           try {
  639               LOOP: for (; ;) {
  640                   SWITCH: switch (token) {
  641                       case TokenType.INT_START:
  642                           if (seenElement)
  643                               return true;
  644                           seenElement = true;
  645                           token = c.toEndToken().intValue();
  646                           break SWITCH;
  647   
  648                       case TokenType.INT_TEXT:
  649                           if (!Locale.isWhiteSpace(c.getChars()))
  650                               return true;
  651                           token = c.toNextToken().intValue();
  652                           break SWITCH;
  653   
  654                       case TokenType.INT_NONE:
  655                       case TokenType.INT_ENDDOC:
  656                           break LOOP;
  657   
  658                       case TokenType.INT_ATTR:
  659                       case TokenType.INT_NAMESPACE:
  660                           return true;
  661   
  662                       case TokenType.INT_END:
  663                       case TokenType.INT_COMMENT:
  664                       case TokenType.INT_PROCINST:
  665                           token = c.toNextToken().intValue();
  666                           break SWITCH;
  667   
  668                       case TokenType.INT_STARTDOC:
  669                           assert false;
  670                           break LOOP;
  671                   }
  672               }
  673           } finally {
  674               c.dispose();
  675           }
  676   
  677           return !seenElement;
  678       }
  679   
  680       private static final class DomSaver extends Saver {
  681           DomSaver(Cur c, boolean isFrag, XmlOptions options) {
  682               super(c, options);
  683   
  684               if (c.isUserNode())
  685                   _type = c.getUser().get_schema_type();
  686   
  687               _stl = c._locale._schemaTypeLoader;
  688               _options = options;
  689               _isFrag = isFrag;
  690           }
  691   
  692           Node saveDom() {
  693               Locale l = Locale.getLocale(_stl, _options);
  694   
  695               l.enter();
  696   
  697               try {
  698                   _nodeCur = l.getCur();  // Not weak or temp
  699   
  700                   // Build the tree
  701                   
  702                   while (process())
  703                       ;
  704   
  705                   // Set the type
  706   
  707                   while (!_nodeCur.isRoot())
  708                       _nodeCur.toParent();
  709   
  710                   if (_type != null)
  711                       _nodeCur.setType(_type);
  712   
  713                   Node node = (Node) _nodeCur.getDom();
  714   
  715                   _nodeCur.release();
  716   
  717                   _nodeCur = null;
  718   
  719                   return node;
  720               } finally {
  721                   l.exit();
  722               }
  723           }
  724   
  725           protected boolean emitElement(SaveCur c, ArrayList attrNames, ArrayList attrValues) {
  726               // If there was text or comments before the frag element, I will loose them -- oh well
  727               // Also, I will lose any attributes and namesapces on the fragment -- DOM can
  728               // have attrs in fragments
  729               
  730               if (Locale.isFragmentQName(c.getName()))
  731                   _nodeCur.moveTo(null, Cur.NO_POS);
  732   
  733               ensureDoc();
  734   
  735               _nodeCur.createElement(getQualifiedName(c, c.getName()));
  736               _nodeCur.next();
  737   
  738               for (iterateMappings(); hasMapping(); nextMapping()) {
  739                   _nodeCur.createAttr(_nodeCur._locale.createXmlns(mappingPrefix()));
  740                   _nodeCur.next();
  741                   _nodeCur.insertString(mappingUri());
  742                   _nodeCur.toParent();
  743                   _nodeCur.skipWithAttrs();
  744               }
  745   
  746               for (int i = 0; i < attrNames.size(); i++) {
  747                   _nodeCur.createAttr(getQualifiedName(c, (QName) attrNames.get(i)));
  748                   _nodeCur.next();
  749                   _nodeCur.insertString((String) attrValues.get(i));
  750                   _nodeCur.toParent();
  751                   _nodeCur.skipWithAttrs();
  752               }
  753   
  754               return false;
  755           }
  756   
  757           protected void emitFinish(SaveCur c) {
  758               if (!Locale.isFragmentQName(c.getName())) {
  759                   assert _nodeCur.isEnd();
  760                   _nodeCur.next();
  761               }
  762           }
  763   
  764           protected void emitText(SaveCur c) {
  765               ensureDoc();
  766   
  767               Object src = c.getChars();
  768   
  769               if (c._cchSrc > 0) {
  770                   _nodeCur.insertChars(src, c._offSrc, c._cchSrc);
  771                   _nodeCur.next();
  772               }
  773           }
  774   
  775           protected void emitComment(SaveCur c) {
  776               ensureDoc();
  777   
  778               _nodeCur.createComment();
  779               emitTextValue(c);
  780               _nodeCur.skip();
  781           }
  782   
  783           protected void emitProcinst(SaveCur c) {
  784               ensureDoc();
  785   
  786               _nodeCur.createProcinst(c.getName().getLocalPart());
  787               emitTextValue(c);
  788               _nodeCur.skip();
  789           }
  790   
  791           protected void emitDocType(String docTypeName, String publicId, String systemId) {
  792               ensureDoc();
  793   
  794               XmlDocumentProperties props = Locale.getDocProps(_nodeCur, true);
  795               props.setDoctypeName(docTypeName);
  796               props.setDoctypePublicId(publicId);
  797               props.setDoctypeSystemId(systemId);
  798           }
  799   
  800           protected void emitStartDoc(SaveCur c) {
  801               ensureDoc();
  802           }
  803   
  804           protected void emitEndDoc ( SaveCur c )
  805           {
  806           }
  807           
  808           private QName getQualifiedName(SaveCur c, QName name) {
  809               String uri = name.getNamespaceURI();
  810   
  811               String prefix = uri.length() > 0 ? getUriMapping(uri) : "";
  812   
  813               if (prefix.equals(name.getPrefix()))
  814                   return name;
  815   
  816               return _nodeCur._locale.makeQName(uri, name.getLocalPart(), prefix);
  817           }
  818   
  819           private void emitTextValue(SaveCur c) {
  820               c.push();
  821               c.next();
  822   
  823               if (c.isText()) {
  824                   _nodeCur.next();
  825                   _nodeCur.insertChars(c.getChars(), c._offSrc, c._cchSrc);
  826                   _nodeCur.toParent();
  827               }
  828   
  829               c.pop();
  830           }
  831   
  832           private void ensureDoc() {
  833               if (!_nodeCur.isPositioned()) {
  834                   if (_isFrag)
  835                       _nodeCur.createDomDocFragRoot();
  836                   else
  837                       _nodeCur.createDomDocumentRoot();
  838   
  839                   _nodeCur.next();
  840               }
  841           }
  842   
  843           private Cur _nodeCur;
  844           private SchemaType _type;
  845           private SchemaTypeLoader _stl;
  846           private XmlOptions _options;
  847           private boolean _isFrag;
  848       }
  849   
  850       public Node _newDomNode(XmlOptions options) {
  851           // Must ignore inner options for compat with v1.
  852           
  853           if (XmlOptions.hasOption(options, XmlOptions.SAVE_INNER)) {
  854               options = new XmlOptions(options);
  855               options.remove(XmlOptions.SAVE_INNER);
  856           }
  857   
  858           return new DomSaver(_cur, isDomFragment(), options).saveDom();
  859       }
  860   
  861       public boolean _toCursor(Cursor other) {
  862           assert _cur._locale == other._cur._locale;
  863   
  864           _cur.moveToCur(other._cur);
  865   
  866           return true;
  867       }
  868   
  869       public void _push() {
  870           _cur.push();
  871       }
  872   
  873       public boolean _pop() {
  874           return _cur.pop();
  875       }
  876   
  877       public void notifyChange() {
  878           // Force any path to get exausted, cursor may be disposed, but still be on the notification
  879           // list.
  880   
  881           if (_cur != null)
  882               _getSelectionCount();
  883       }
  884   
  885       public void setNextChangeListener(ChangeListener listener) {
  886           _nextChangeListener = listener;
  887       }
  888   
  889       public ChangeListener getNextChangeListener() {
  890           return _nextChangeListener;
  891       }
  892   
  893       public void _selectPath(String path) {
  894           _selectPath(path, null);
  895       }
  896   
  897       public void _selectPath(String pathExpr, XmlOptions options) {
  898           _clearSelections();
  899   
  900           assert _pathEngine == null;
  901   
  902           _pathEngine = Path.getCompiledPath(pathExpr, options).execute(_cur, options);
  903   
  904           _cur._locale.registerForChange(this);
  905       }
  906   
  907       public boolean _hasNextSelection() {
  908           int curr = _currentSelection;
  909           push();
  910   
  911           try {
  912               return _toNextSelection();
  913           } finally {
  914               _currentSelection = curr;
  915               pop();
  916           }
  917       }
  918   
  919       public boolean _toNextSelection() {
  920           return _toSelection(_currentSelection + 1);
  921       }
  922   
  923       public boolean _toSelection(int i) {
  924           if (i < 0)
  925               return false;
  926   
  927           while (i >= _cur.selectionCount()) {
  928               if (_pathEngine == null)
  929                   return false;
  930   
  931               if (!_pathEngine.next(_cur)) {
  932                   _pathEngine.release();
  933                   _pathEngine = null;
  934   
  935                   return false;
  936               }
  937           }
  938   
  939           _cur.moveToSelection(_currentSelection = i);
  940   
  941           return true;
  942       }
  943   
  944       public int _getSelectionCount() {
  945           // Should never get to MAX_VALUE selection index, so, state should not change
  946           _toSelection(Integer.MAX_VALUE);
  947   
  948           return _cur.selectionCount();
  949       }
  950   
  951       public void _addToSelection() {
  952           _toSelection(Integer.MAX_VALUE);
  953   
  954           _cur.addToSelection();
  955       }
  956   
  957       public void _clearSelections() {
  958           if (_pathEngine != null) {
  959               _pathEngine.release();
  960               _pathEngine = null;
  961           }
  962   
  963           _cur.clearSelection();
  964   
  965           _currentSelection = -1;
  966       }
  967   
  968       public String _namespaceForPrefix(String prefix) {
  969           if (!_cur.isContainer())
  970               throw new IllegalStateException("Not on a container");
  971   
  972           return _cur.namespaceForPrefix(prefix, true);
  973       }
  974   
  975       public String _prefixForNamespace(String ns) {
  976           if (ns == null || ns.length() == 0)
  977               throw new IllegalArgumentException("Must specify a namespace");
  978   
  979   // Note: I loosen this requirement in v2, can call this from anywhere
  980   //        if (!_cur.isContainer())
  981   //            throw new IllegalStateException( "Not on a container" );
  982   
  983           return _cur.prefixForNamespace(ns, null, true);
  984       }
  985   
  986       public void _getAllNamespaces(Map addToThis) {
  987           if (!_cur.isContainer())
  988               throw new IllegalStateException("Not on a container");
  989   
  990           if (addToThis != null)
  991               Locale.getAllNamespaces(_cur, addToThis);
  992       }
  993   
  994       public XmlObject _getObject() {
  995           return _cur.getObject();
  996       }
  997   
  998       public TokenType _prevTokenType() {
  999           _cur.push();
 1000   
 1001           TokenType tt = _toPrevToken();
 1002   
 1003           _cur.pop();
 1004   
 1005           return tt;
 1006       }
 1007   
 1008       public boolean _hasNextToken() {
 1009           //return _cur.kind() != -ROOT;
 1010           return _cur._pos!=Cur.END_POS || _cur._xobj.kind()!=ROOT;
 1011       }
 1012   
 1013       public boolean _hasPrevToken() {
 1014           return _cur.kind() != ROOT;
 1015       }
 1016   
 1017       public TokenType _toFirstContentToken() {
 1018           if (!_cur.isContainer())
 1019               return TokenType.NONE;
 1020   
 1021           _cur.next();
 1022   
 1023           return currentTokenType();
 1024       }
 1025   
 1026       public TokenType _toEndToken() {
 1027           if (!_cur.isContainer())
 1028               return TokenType.NONE;
 1029   
 1030           _cur.toEnd();
 1031   
 1032           return currentTokenType();
 1033       }
 1034   
 1035       public boolean _toChild(String local) {
 1036           return _toChild(null, local);
 1037       }
 1038   
 1039       public boolean _toChild(QName name) {
 1040           return _toChild(name, 0);
 1041       }
 1042   
 1043       public boolean _toChild(int index) {
 1044           return _toChild(null, index);
 1045       }
 1046   
 1047       public boolean _toChild(String uri, String local) {
 1048           validateLocalName(local);
 1049   
 1050           return _toChild(_cur._locale.makeQName(uri, local), 0);
 1051       }
 1052   
 1053       public boolean _toChild(QName name, int index) {
 1054           return Locale.toChild(_cur, name, index);
 1055       }
 1056   
 1057       public int _toNextChar(int maxCharacterCount) {
 1058           return _cur.nextChars(maxCharacterCount);
 1059       }
 1060   
 1061       public int _toPrevChar(int maxCharacterCount) {
 1062           return _cur.prevChars(maxCharacterCount);
 1063       }
 1064   
 1065       public boolean _toPrevSibling() {
 1066           return Locale.toPrevSiblingElement(_cur);
 1067       }
 1068   
 1069       public boolean _toLastChild() {
 1070           return Locale.toLastChildElement(_cur);
 1071       }
 1072   
 1073       public boolean _toFirstChild() {
 1074           return Locale.toFirstChildElement(_cur);
 1075       }
 1076   
 1077       public boolean _toNextSibling(String name) {
 1078           return _toNextSibling(new QName(name));
 1079       }
 1080   
 1081       public boolean _toNextSibling(String uri, String local) {
 1082           validateLocalName(local);
 1083   
 1084           return _toNextSibling(_cur._locale._qnameFactory.getQName(uri, local));
 1085       }
 1086   
 1087       public boolean _toNextSibling(QName name) {
 1088           _cur.push();
 1089   
 1090           while (___toNextSibling()) {
 1091               if (_cur.getName().equals(name)) {
 1092                   _cur.popButStay();
 1093                   return true;
 1094               }
 1095           }
 1096   
 1097           _cur.pop();
 1098   
 1099           return false;
 1100       }
 1101   
 1102       public boolean _toFirstAttribute() {
 1103           return _cur.isContainer() && Locale.toFirstNormalAttr(_cur);
 1104       }
 1105   
 1106       public boolean _toLastAttribute() {
 1107           if (_cur.isContainer()) {
 1108               _cur.push();
 1109               _cur.push();
 1110   
 1111               boolean foundAttr = false;
 1112   
 1113               while (_cur.toNextAttr()) {
 1114                   if (_cur.isNormalAttr()) {
 1115                       _cur.popButStay();
 1116                       _cur.push();
 1117                       foundAttr = true;
 1118                   }
 1119               }
 1120   
 1121               _cur.pop();
 1122   
 1123               if (foundAttr) {
 1124                   _cur.popButStay();
 1125                   return true;
 1126               }
 1127   
 1128               _cur.pop();
 1129           }
 1130   
 1131           return false;
 1132       }
 1133   
 1134       public boolean _toNextAttribute() {
 1135           return _cur.isAttr() && Locale.toNextNormalAttr(_cur);
 1136       }
 1137   
 1138       public boolean _toPrevAttribute() {
 1139           return _cur.isAttr() && Locale.toPrevNormalAttr(_cur);
 1140       }
 1141   
 1142       public String _getAttributeText(QName attrName) {
 1143           if (attrName == null)
 1144               throw new IllegalArgumentException("Attr name is null");
 1145   
 1146           if (!_cur.isContainer())
 1147               return null;
 1148   
 1149           return _cur.getAttrValue(attrName);
 1150       }
 1151   
 1152       public boolean _setAttributeText(QName attrName, String value) {
 1153           if (attrName == null)
 1154               throw new IllegalArgumentException("Attr name is null");
 1155   
 1156           validateLocalName(attrName.getLocalPart());
 1157   
 1158           if (!_cur.isContainer())
 1159               return false;
 1160   
 1161           _cur.setAttrValue(attrName, value);
 1162   
 1163           return true;
 1164       }
 1165   
 1166       public boolean _removeAttribute(QName attrName) {
 1167           if (attrName == null)
 1168               throw new IllegalArgumentException("Attr name is null");
 1169   
 1170           if (!_cur.isContainer())
 1171               return false;
 1172   
 1173           return _cur.removeAttr(attrName);
 1174       }
 1175   
 1176       public String _getTextValue() {
 1177           if (_cur.isText())
 1178               return _getChars();
 1179   
 1180           if (!_cur.isNode()) {
 1181               throw new IllegalStateException("Can't get text value, current token can have no text value");
 1182           }
 1183   
 1184           return _cur.hasChildren() ? Locale.getTextValue(_cur) : _cur.getValueAsString();
 1185       }
 1186   
 1187       public int _getTextValue(char[] chars, int offset, int max) {
 1188           if (_cur.isText())
 1189               return _getChars(chars, offset, max);
 1190   
 1191           if (chars == null)
 1192               throw new IllegalArgumentException("char buffer is null");
 1193   
 1194           if (offset < 0)
 1195               throw new IllegalArgumentException("offset < 0");
 1196   
 1197           if (offset >= chars.length)
 1198               throw new IllegalArgumentException("offset off end");
 1199   
 1200           if (max < 0)
 1201               max = Integer.MAX_VALUE;
 1202   
 1203           if (offset + max > chars.length)
 1204               max = chars.length - offset;
 1205   
 1206           if (!_cur.isNode()) {
 1207               throw new IllegalStateException("Can't get text value, current token can have no text value");
 1208           }
 1209   
 1210           // If there are no children (hopefully the common case), I can get the text faster.
 1211   
 1212           if (_cur.hasChildren())
 1213               return Locale.getTextValue(_cur, Locale.WS_PRESERVE, chars, offset, max);
 1214   
 1215           // Fast way
 1216               
 1217           Object src = _cur.getFirstChars();
 1218   
 1219           if (_cur._cchSrc > max)
 1220               _cur._cchSrc = max;
 1221   
 1222           if (_cur._cchSrc <= 0)
 1223               return 0;
 1224   
 1225           CharUtil.getChars(chars, offset, src, _cur._offSrc, _cur._cchSrc);
 1226   
 1227           return _cur._cchSrc;
 1228       }
 1229   
 1230       private void setTextValue(Object src, int off, int cch) {
 1231           if (!_cur.isNode()) {
 1232               throw new IllegalStateException("Can't set text value, current token can have no text value");
 1233           }
 1234   
 1235           _cur.moveNodeContents(null, false);
 1236           _cur.next();
 1237           _cur.insertChars(src, off, cch);
 1238           _cur.toParent();
 1239       }
 1240   
 1241       public void _setTextValue(String text) {
 1242           if (text == null)
 1243               text = "";
 1244   
 1245           setTextValue(text, 0, text.length());
 1246       }
 1247   
 1248       public void _setTextValue(char[] sourceChars, int offset, int length) {
 1249           if (length < 0)
 1250               throw new IndexOutOfBoundsException("setTextValue: length < 0");
 1251   
 1252           if (sourceChars == null) {
 1253               if (length > 0)
 1254                   throw new IllegalArgumentException("setTextValue: sourceChars == null");
 1255   
 1256               setTextValue(null, 0, 0);
 1257   
 1258               return;
 1259           }
 1260   
 1261           if (offset < 0 || offset >= sourceChars.length)
 1262               throw new IndexOutOfBoundsException("setTextValue: offset out of bounds");
 1263   
 1264           if (offset + length > sourceChars.length)
 1265               length = sourceChars.length - offset;
 1266   
 1267           CharUtil cu = _cur._locale.getCharUtil();
 1268   
 1269           setTextValue(cu.saveChars(sourceChars, offset, length), cu._offSrc, cu._cchSrc);
 1270       }
 1271   
 1272       public String _getChars() {
 1273           return _cur.getCharsAsString(-1);
 1274       }
 1275   
 1276       public int _getChars(char[] buf, int off, int cch) {
 1277           int cchRight = _cur.cchRight();
 1278   
 1279           if (cch < 0 || cch > cchRight)
 1280               cch = cchRight;
 1281   
 1282           if (buf == null || off >= buf.length)
 1283               return 0;
 1284   
 1285           if (buf.length - off < cch)
 1286               cch = buf.length - off;
 1287   
 1288           Object src = _cur.getChars(cch);
 1289   
 1290           CharUtil.getChars(buf, off, src, _cur._offSrc, _cur._cchSrc);
 1291   
 1292           return _cur._cchSrc;
 1293       }
 1294   
 1295       public void _toStartDoc() {
 1296   //        while (_cur.toParent())
 1297   //            ;
 1298             _cur.toRoot();
 1299       }
 1300   
 1301       public void _toEndDoc() {
 1302           _toStartDoc();
 1303   
 1304           _cur.toEnd();
 1305       }
 1306   
 1307       public int _comparePosition(Cursor other) {
 1308           int s = _cur.comparePosition(other._cur);
 1309   
 1310           if (s == 2)
 1311               throw new IllegalArgumentException("Cursors not in same document");
 1312   
 1313           assert s >= -1 && s <= 1;
 1314   
 1315           return s;
 1316       }
 1317   
 1318       public boolean _isLeftOf(Cursor other) {
 1319           return _comparePosition(other) < 0;
 1320       }
 1321   
 1322       public boolean _isAtSamePositionAs(Cursor other) {
 1323           return _cur.isSamePos(other._cur);
 1324       }
 1325   
 1326       public boolean _isRightOf(Cursor other) {
 1327           return _comparePosition(other) > 0;
 1328       }
 1329   
 1330       public XmlCursor _execQuery(String query) {
 1331           return _execQuery(query, null);
 1332       }
 1333   
 1334       public XmlCursor _execQuery(String query, XmlOptions options) {
 1335               checkThisCursor();
 1336               return Query.cursorExecQuery(_cur,query,options);
 1337   
 1338       }
 1339   
 1340   
 1341       public boolean _toBookmark(XmlBookmark bookmark) {
 1342           if (bookmark == null || !(bookmark._currentMark instanceof Xobj.Bookmark))
 1343               return false;
 1344   
 1345           Xobj.Bookmark m = (Xobj.Bookmark) bookmark._currentMark;
 1346   
 1347           if (m._xobj == null || m._xobj._locale != _cur._locale)
 1348               return false;
 1349   
 1350           _cur.moveTo(m._xobj, m._pos);
 1351   
 1352           return true;
 1353       }
 1354   
 1355       public XmlBookmark _toNextBookmark(Object key) {
 1356           if (key == null)
 1357               return null;
 1358   
 1359           int cch;
 1360   
 1361           _cur.push();
 1362   
 1363           for (; ;) {
 1364               // Move a minimal amount.  If at text, move to a potential bookmark in the text.
 1365               
 1366               if ((cch = _cur.cchRight()) > 1) {
 1367                   _cur.nextChars(1);
 1368                   _cur.nextChars((cch = _cur.firstBookmarkInChars(key, cch - 1)) >= 0 ? cch : -1);
 1369               } else if (_toNextToken().isNone()) {
 1370                   _cur.pop();
 1371                   return null;
 1372               }
 1373   
 1374               XmlBookmark bm = getBookmark(key, _cur);
 1375   
 1376               if (bm != null) {
 1377                   _cur.popButStay();
 1378                   return bm;
 1379               }
 1380   
 1381               if (_cur.kind() == -ROOT) {
 1382                   _cur.pop();
 1383                   return null;
 1384               }
 1385           }
 1386       }
 1387   
 1388       public XmlBookmark _toPrevBookmark(Object key) {
 1389           if (key == null)
 1390               return null;
 1391   
 1392           int cch;
 1393   
 1394           _cur.push();
 1395   
 1396           for (; ;) {
 1397               // Move a minimal amount.  If at text, move to a potential bookmark in the text.
 1398               
 1399               if ((cch = _cur.cchLeft()) > 1) {
 1400                   _cur.prevChars(1);
 1401   
 1402                   _cur.prevChars((cch = _cur.firstBookmarkInCharsLeft(key, cch - 1)) >= 0 ? cch : -1);
 1403               } else if (cch == 1) {
 1404                   // _toPrevToken will not skip to the beginning of the text, it will go further
 1405                   // so that the token to the right is not text.  I need to simply skip to
 1406                   // the beginning of the text ...
 1407                   
 1408                   _cur.prevChars(1);
 1409               } else if (_toPrevToken().isNone()) {
 1410                   _cur.pop();
 1411                   return null;
 1412               }
 1413   
 1414               XmlBookmark bm = getBookmark(key, _cur);
 1415   
 1416               if (bm != null) {
 1417                   _cur.popButStay();
 1418                   return bm;
 1419               }
 1420   
 1421               if (_cur.kind() == ROOT) {
 1422                   _cur.pop();
 1423                   return null;
 1424               }
 1425           }
 1426       }
 1427   
 1428       public void _setBookmark(XmlBookmark bookmark) {
 1429           if (bookmark != null) {
 1430               if (bookmark.getKey() == null)
 1431                   throw new IllegalArgumentException("Annotation key is null");
 1432               
 1433               // TODO - I Don't do weak bookmarks yet ... perhaps I'll never do them ....
 1434   
 1435               bookmark._currentMark = _cur.setBookmark(bookmark.getKey(), bookmark);
 1436           }
 1437       }
 1438   
 1439       static XmlBookmark getBookmark(Object key, Cur c) {
 1440           // TODO - I Don't do weak bookmarks yet ...
 1441   
 1442           if (key == null)
 1443               return null;
 1444   
 1445           Object bm = c.getBookmark(key);
 1446   
 1447           return bm != null && bm instanceof XmlBookmark ? (XmlBookmark) bm : null;
 1448       }
 1449   
 1450       public XmlBookmark _getBookmark(Object key) {
 1451           return key == null ? null : getBookmark(key, _cur);
 1452       }
 1453   
 1454       public void _clearBookmark(Object key) {
 1455           if (key != null)
 1456               _cur.setBookmark(key, null);
 1457       }
 1458   
 1459       public void _getAllBookmarkRefs(Collection listToFill) {
 1460           if (listToFill != null) {
 1461               for (Xobj.Bookmark b = _cur._xobj._bookmarks; b != null; b = b._next)
 1462                   if (b._value instanceof XmlBookmark)
 1463                       listToFill.add(b._value);
 1464           }
 1465       }
 1466   
 1467       public boolean _removeXml() {
 1468           if (_cur.isRoot())
 1469               throw new IllegalStateException("Can't remove a whole document.");
 1470   
 1471           if (_cur.isFinish())
 1472               return false;
 1473   
 1474           assert _cur.isText() || _cur.isNode();
 1475   
 1476           if (_cur.isText())
 1477               _cur.moveChars(null, -1);
 1478           else
 1479               _cur.moveNode(null);
 1480   
 1481           return true;
 1482       }
 1483   
 1484       public boolean _moveXml(Cursor to) {
 1485           to.checkInsertionValidity(_cur);
 1486   
 1487           // Check for a no-op
 1488           
 1489           if (_cur.isText()) {
 1490               int cchRight = _cur.cchRight();
 1491   
 1492               assert cchRight > 0;
 1493   
 1494               if (_cur.inChars(to._cur, cchRight, true))
 1495                   return false;
 1496   
 1497               _cur.moveChars(to._cur, cchRight);
 1498   
 1499               to._cur.nextChars(cchRight);
 1500   
 1501               return true;
 1502           }
 1503   
 1504           if (_cur.contains(to._cur))
 1505               return false;
 1506   
 1507           // Make a cur which will float to the right of the insertion
 1508           
 1509           Cur c = to.tempCur();
 1510   
 1511           _cur.moveNode(to._cur);
 1512   
 1513           to._cur.moveToCur(c);
 1514   
 1515           c.release();
 1516   
 1517           return true;
 1518       }
 1519   
 1520       public boolean _copyXml(Cursor to) {
 1521           to.checkInsertionValidity(_cur);
 1522   
 1523           assert _cur.isText() || _cur.isNode();
 1524   
 1525           Cur c = to.tempCur();
 1526   
 1527           if (_cur.isText())
 1528               to._cur.insertChars(_cur.getChars(-1), _cur._offSrc, _cur._cchSrc);
 1529           else
 1530               _cur.copyNode(to._cur);
 1531   
 1532           to._cur.moveToCur(c);
 1533   
 1534           c.release();
 1535   
 1536           return true;
 1537       }
 1538   
 1539       public boolean _removeXmlContents() {
 1540           if (!_cur.isContainer())
 1541               return false;
 1542   
 1543           _cur.moveNodeContents(null, false);
 1544   
 1545           return true;
 1546       }
 1547   
 1548       private boolean checkContentInsertionValidity(Cursor to) {
 1549           _cur.push();
 1550   
 1551           _cur.next();
 1552   
 1553           if (_cur.isFinish()) {
 1554               _cur.pop();
 1555               return false;
 1556           }
 1557   
 1558           try {
 1559               to.checkInsertionValidity(_cur);
 1560           } catch (IllegalArgumentException e) {
 1561               _cur.pop();
 1562               throw e;
 1563           }
 1564   
 1565           _cur.pop();
 1566   
 1567           return true;
 1568       }
 1569   
 1570       public boolean _moveXmlContents(Cursor to) {
 1571           if (!_cur.isContainer() || _cur.contains(to._cur))
 1572               return false;
 1573   
 1574           if (!checkContentInsertionValidity(to))
 1575               return false;
 1576   
 1577           Cur c = to.tempCur();
 1578   
 1579           _cur.moveNodeContents(to._cur, false);
 1580   
 1581           to._cur.moveToCur(c);
 1582   
 1583           c.release();
 1584   
 1585           return true;
 1586       }
 1587   
 1588       public boolean _copyXmlContents(Cursor to) {
 1589           if (!_cur.isContainer() || _cur.contains(to._cur))
 1590               return false;
 1591   
 1592           if (!checkContentInsertionValidity(to))
 1593               return false;
 1594   
 1595           // I don't have a primitive to copy contents, make a copy of the node and them move the
 1596           // contents
 1597   
 1598           Cur c = _cur._locale.tempCur();
 1599   
 1600           _cur.copyNode(c);
 1601   
 1602           Cur c2 = to._cur.tempCur();
 1603   
 1604           c.moveNodeContents(to._cur, false);
 1605   
 1606           c.release();
 1607   
 1608           to._cur.moveToCur(c2);
 1609   
 1610           c2.release();
 1611   
 1612           return true;
 1613       }
 1614   
 1615       public int _removeChars(int cch) {
 1616           int cchRight = _cur.cchRight();
 1617   
 1618           if (cchRight == 0 || cch == 0)
 1619               return 0;
 1620   
 1621           if (cch < 0 || cch > cchRight)
 1622               cch = cchRight;
 1623   
 1624           _cur.moveChars(null, cch);
 1625   
 1626           return _cur._cchSrc;
 1627       }
 1628   
 1629       public int _moveChars(int cch, Cursor to) {
 1630           int cchRight = _cur.cchRight();
 1631   
 1632           if (cchRight <= 0 || cch == 0)
 1633               return 0;
 1634   
 1635           if (cch < 0 || cch > cchRight)
 1636               cch = cchRight;
 1637   
 1638           to.checkInsertionValidity(_cur);
 1639   
 1640           _cur.moveChars(to._cur, cch);
 1641   
 1642           to._cur.nextChars(_cur._cchSrc);
 1643   
 1644           return _cur._cchSrc;
 1645       }
 1646   
 1647       public int _copyChars(int cch, Cursor to) {
 1648           int cchRight = _cur.cchRight();
 1649   
 1650           if (cchRight <= 0 || cch == 0)
 1651               return 0;
 1652   
 1653           if (cch < 0 || cch > cchRight)
 1654               cch = cchRight;
 1655   
 1656           to.checkInsertionValidity(_cur);
 1657   
 1658           to._cur.insertChars(_cur.getChars(cch), _cur._offSrc, _cur._cchSrc);
 1659   
 1660           to._cur.nextChars(_cur._cchSrc);
 1661   
 1662           return _cur._cchSrc;
 1663       }
 1664   
 1665       public void _insertChars(String text) {
 1666           int l = text == null ? 0 : text.length();
 1667   
 1668           if (l > 0) {
 1669               if (_cur.isRoot() || _cur.isAttr()) {
 1670                   throw
 1671                           new IllegalStateException("Can't insert before the document or an attribute.");
 1672               }
 1673   
 1674               _cur.insertChars(text, 0, l);
 1675               _cur.nextChars(l);
 1676           }
 1677       }
 1678   
 1679       //
 1680       // Inserting elements
 1681       //
 1682       
 1683       public void _beginElement(String localName) {
 1684           _insertElementWithText(localName, null, null);
 1685           _toPrevToken();
 1686       }
 1687   
 1688       public void _beginElement(String localName, String uri) {
 1689           _insertElementWithText(localName, uri, null);
 1690           _toPrevToken();
 1691       }
 1692   
 1693       public void _beginElement(QName name) {
 1694           _insertElementWithText(name, null);
 1695           _toPrevToken();
 1696       }
 1697   
 1698       public void _insertElement(String localName) {
 1699           _insertElementWithText(localName, null, null);
 1700       }
 1701   
 1702       public void _insertElement(String localName, String uri) {
 1703           _insertElementWithText(localName, uri, null);
 1704       }
 1705   
 1706       public void _insertElement(QName name) {
 1707           _insertElementWithText(name, null);
 1708       }
 1709   
 1710       public void _insertElementWithText(String localName, String text) {
 1711           _insertElementWithText(localName, null, text);
 1712       }
 1713   
 1714       public void _insertElementWithText(String localName, String uri, String text) {
 1715           validateLocalName(localName);
 1716   
 1717           _insertElementWithText(_cur._locale.makeQName(uri, localName), text);
 1718       }
 1719   
 1720       public void _insertElementWithText(QName name, String text) {
 1721           validateLocalName(name.getLocalPart());
 1722   
 1723           Cur c = _cur._locale.tempCur();
 1724   
 1725           c.createElement(name);
 1726   
 1727           insertNode(c, text);
 1728   
 1729           c.release();
 1730       }
 1731   
 1732       //
 1733       //
 1734       //
 1735       
 1736       public void _insertAttribute(String localName) {
 1737           _insertAttributeWithValue(localName, null);
 1738       }
 1739   
 1740       public void _insertAttribute(String localName, String uri) {
 1741           _insertAttributeWithValue(localName, uri, null);
 1742       }
 1743   
 1744       public void _insertAttribute(QName name) {
 1745           _insertAttributeWithValue(name, null);
 1746       }
 1747   
 1748       public void _insertAttributeWithValue(String localName, String value) {
 1749           _insertAttributeWithValue(localName, null, value);
 1750       }
 1751   
 1752       public void _insertAttributeWithValue(String localName, String uri, String value) {
 1753           validateLocalName(localName);
 1754   
 1755           _insertAttributeWithValue(_cur._locale.makeQName(uri, localName), value);
 1756       }
 1757   
 1758       public void _insertAttributeWithValue(QName name, String text) {
 1759           validateLocalName(name.getLocalPart());
 1760   
 1761           Cur c = _cur._locale.tempCur();
 1762   
 1763           c.createAttr(name);
 1764   
 1765           insertNode(c, text);
 1766   
 1767           c.release();
 1768       }
 1769   
 1770       //
 1771       //
 1772       //
 1773       
 1774       public void _insertNamespace(String prefix, String namespace) {
 1775           _insertAttributeWithValue(_cur._locale.createXmlns(prefix), namespace);
 1776       }
 1777   
 1778       public void _insertComment(String text) {
 1779           Cur c = _cur._locale.tempCur();
 1780   
 1781           c.createComment();
 1782   
 1783           insertNode(c, text);
 1784   
 1785           c.release();
 1786       }
 1787   
 1788       public void _insertProcInst(String target, String text) {
 1789           validateLocalName(target);
 1790   
 1791           if (Locale.beginsWithXml(target) && target.length() == 3)
 1792               throw new IllegalArgumentException("Target is 'xml'");
 1793   
 1794           Cur c = _cur._locale.tempCur();
 1795   
 1796           c.createProcinst(target);
 1797   
 1798           insertNode(c, text);
 1799   
 1800           c.release();
 1801       }
 1802   
 1803       public void _dump() {
 1804           _cur.dump();
 1805       }
 1806   
 1807       //
 1808       //
 1809       //
 1810       //
 1811       //
 1812       //
 1813       //
 1814   
 1815       private void checkThisCursor() {
 1816           if (_cur == null)
 1817               throw new IllegalStateException("This cursor has been disposed");
 1818       }
 1819   
 1820       private Cursor checkCursors(XmlCursor xOther) {
 1821           checkThisCursor();
 1822   
 1823           if (xOther == null)
 1824               throw new IllegalArgumentException("Other cursor is <null>");
 1825   
 1826           if (!(xOther instanceof Cursor))
 1827               throw new IllegalArgumentException("Incompatible cursors: " + xOther);
 1828   
 1829           Cursor other = (Cursor) xOther;
 1830   
 1831           if (other._cur == null)
 1832               throw new IllegalStateException("Other cursor has been disposed");
 1833   
 1834           return other;
 1835       }
 1836       
 1837       //
 1838       // The following operations have two cursors, and can be in different documents
 1839       //
 1840   
 1841       private static final int MOVE_XML = 0;
 1842       private static final int COPY_XML = 1;
 1843       private static final int MOVE_XML_CONTENTS = 2;
 1844       private static final int COPY_XML_CONTENTS = 3;
 1845       private static final int MOVE_CHARS = 4;
 1846       private static final int COPY_CHARS = 5;
 1847   
 1848       private int twoLocaleOp(XmlCursor xOther, int op, int arg) {
 1849           Cursor other = checkCursors(xOther);
 1850   
 1851           Locale locale = _cur._locale;
 1852           Locale otherLocale = other._cur._locale;
 1853   
 1854           if (locale == otherLocale) {
 1855               if (locale.noSync())
 1856                   return twoLocaleOp(other, op, arg);
 1857               else {
 1858                   synchronized (locale) {
 1859                       return twoLocaleOp(other, op, arg);
 1860                   }
 1861               }
 1862           }
 1863   
 1864           if (locale.noSync()) {
 1865               if (otherLocale.noSync())
 1866                   return twoLocaleOp(other, op, arg);
 1867               else {
 1868                   synchronized (otherLocale) {
 1869                       return twoLocaleOp(other, op, arg);
 1870                   }
 1871               }
 1872           } else if (otherLocale.noSync()) {
 1873               synchronized (locale) {
 1874                   return twoLocaleOp(other, op, arg);
 1875               }
 1876           }
 1877   
 1878           boolean acquired = false;
 1879   
 1880           try {
 1881               GlobalLock.acquire();
 1882               acquired = true;
 1883   
 1884               synchronized (locale) {
 1885                   synchronized (otherLocale) {
 1886                       GlobalLock.release();
 1887                       acquired = false;
 1888   
 1889                       return twoLocaleOp(other, op, arg);
 1890                   }
 1891               }
 1892           } catch (InterruptedException e) {
 1893               throw new RuntimeException(e.getMessage(), e);
 1894           } finally {
 1895               if (acquired)
 1896                   GlobalLock.release();
 1897           }
 1898       }
 1899   
 1900       private int twoLocaleOp(Cursor other, int op, int arg) {
 1901           Locale locale = _cur._locale;
 1902           Locale otherLocale = other._cur._locale;
 1903   
 1904           locale.enter(otherLocale);
 1905   
 1906           try {
 1907               switch (op) {
 1908                   case MOVE_XML:
 1909                       return _moveXml(other) ? 1 : 0;
 1910                   case COPY_XML:
 1911                       return _copyXml(other) ? 1 : 0;
 1912                   case MOVE_XML_CONTENTS:
 1913                       return _moveXmlContents(other) ? 1 : 0;
 1914                   case COPY_XML_CONTENTS:
 1915                       return _copyXmlContents(other) ? 1 : 0;
 1916                   case MOVE_CHARS:
 1917                       return _moveChars(arg, other);
 1918                   case COPY_CHARS:
 1919                       return _copyChars(arg, other);
 1920   
 1921                   default :
 1922                       throw new RuntimeException("Unknown operation: " + op);
 1923               }
 1924           } finally {
 1925               locale.exit(otherLocale);
 1926           }
 1927       }
 1928   
 1929       public boolean moveXml(XmlCursor xTo) {
 1930           return twoLocaleOp(xTo, MOVE_XML, 0) == 1;
 1931       }
 1932   
 1933       public boolean copyXml(XmlCursor xTo) {
 1934           return twoLocaleOp(xTo, COPY_XML, 0) == 1;
 1935       }
 1936   
 1937       public boolean moveXmlContents(XmlCursor xTo) {
 1938           return twoLocaleOp(xTo, MOVE_XML_CONTENTS, 0) == 1;
 1939       }
 1940   
 1941       public boolean copyXmlContents(XmlCursor xTo) {
 1942           return twoLocaleOp(xTo, COPY_XML_CONTENTS, 0) == 1;
 1943       }
 1944   
 1945       public int moveChars(int cch, XmlCursor xTo) {
 1946           return twoLocaleOp(xTo, MOVE_CHARS, cch);
 1947       }
 1948   
 1949       public int copyChars(int cch, XmlCursor xTo) {
 1950           return twoLocaleOp(xTo, COPY_CHARS, cch);
 1951       }
 1952   
 1953       //
 1954       // Special methods involving multiple cursors which can be in different locales, but do not
 1955       // require sync on both locales.
 1956       //
 1957   
 1958       public boolean toCursor(XmlCursor xOther) {
 1959           // One may only move cursors within the same locale
 1960           
 1961           Cursor other = checkCursors(xOther);
 1962   
 1963           if (_cur._locale != other._cur._locale)
 1964               return false;
 1965   
 1966           if (_cur._locale.noSync()) {
 1967               _cur._locale.enter();
 1968               try {
 1969                   return _toCursor(other);
 1970               } finally {
 1971                   _cur._locale.exit();
 1972               }
 1973           } else {
 1974               synchronized (_cur._locale) {
 1975                   _cur._locale.enter();
 1976                   try {
 1977                       return _toCursor(other);
 1978                   } finally {
 1979                       _cur._locale.exit();
 1980                   }
 1981               }
 1982           }
 1983       }
 1984   
 1985       public boolean isInSameDocument(XmlCursor xOther) {
 1986           return xOther == null ? false : _cur.isInSameTree(checkCursors(xOther)._cur);
 1987       }
 1988   
 1989       //
 1990       // The following operations have two cursors, but they must be in the same document
 1991       //
 1992   
 1993       private Cursor preCheck(XmlCursor xOther) {
 1994           Cursor other = checkCursors(xOther);
 1995   
 1996           if (_cur._locale != other._cur._locale)
 1997               throw new IllegalArgumentException("Cursors not in same document");
 1998   
 1999           return other;
 2000       }
 2001   
 2002       public int comparePosition(XmlCursor xOther) {
 2003           Cursor other = preCheck(xOther);
 2004           if (_cur._locale.noSync()) {
 2005               _cur._locale.enter();
 2006               try {
 2007                   return _comparePosition(other);
 2008               } finally {
 2009                   _cur._locale.exit();
 2010               }
 2011           } else synchronized (_cur._locale) {
 2012               _cur._locale.enter();
 2013               try {
 2014                   return _comparePosition(other);
 2015               } finally {
 2016                   _cur._locale.exit();
 2017               }
 2018           }
 2019       }
 2020   
 2021       public boolean isLeftOf(XmlCursor xOther) {
 2022           Cursor other = preCheck(xOther);
 2023           if (_cur._locale.noSync()) {
 2024               _cur._locale.enter();
 2025               try {
 2026                   return _isLeftOf(other);
 2027               } finally {
 2028                   _cur._locale.exit();
 2029               }
 2030           } else synchronized (_cur._locale) {
 2031               _cur._locale.enter();
 2032               try {
 2033                   return _isLeftOf(other);
 2034               } finally {
 2035                   _cur._locale.exit();
 2036               }
 2037           }
 2038       }
 2039   
 2040       public boolean isAtSamePositionAs(XmlCursor xOther) {
 2041           Cursor other = preCheck(xOther);
 2042           if (_cur._locale.noSync()) {
 2043               _cur._locale.enter();
 2044               try {
 2045                   return _isAtSamePositionAs(other);
 2046               } finally {
 2047                   _cur._locale.exit();
 2048               }
 2049           } else synchronized (_cur._locale) {
 2050               _cur._locale.enter();
 2051               try {
 2052                   return _isAtSamePositionAs(other);
 2053               } finally {
 2054                   _cur._locale.exit();
 2055               }
 2056           }
 2057       }
 2058   
 2059       public boolean isRightOf(XmlCursor xOther) {
 2060           Cursor other = preCheck(xOther);
 2061           if (_cur._locale.noSync()) {
 2062               _cur._locale.enter();
 2063               try {
 2064                   return _isRightOf(other);
 2065               } finally {
 2066                   _cur._locale.exit();
 2067               }
 2068           } else synchronized (_cur._locale) {
 2069               _cur._locale.enter();
 2070               try {
 2071                   return _isRightOf(other);
 2072               } finally {
 2073                   _cur._locale.exit();
 2074               }
 2075           }
 2076       }
 2077       
 2078       //
 2079       // Create a cursor from an Xobj -- used for XmlBookmark.createCursor
 2080       //
 2081       
 2082       public static XmlCursor newCursor(Xobj x, int p) {
 2083           Locale l = x._locale;
 2084           if (l.noSync()) {
 2085               l.enter();
 2086               try {
 2087                   return new Cursor(x, p);
 2088               } finally {
 2089                   l.exit();
 2090               }
 2091           } else synchronized (l) {
 2092               l.enter();
 2093               try {
 2094                   return new Cursor(x, p);
 2095               } finally {
 2096                   l.exit();
 2097               }
 2098           }
 2099       }
 2100       
 2101       //
 2102       // The following operations involve only one cursor
 2103       //
 2104   
 2105       private boolean preCheck() {
 2106           checkThisCursor();
 2107           return _cur._locale.noSync();
 2108       }
 2109   
 2110       public void dispose() {
 2111           if (_cur != null) {
 2112               Locale l = _cur._locale;
 2113               if (preCheck()) {
 2114                   l.enter();
 2115                   try {
 2116                       _dispose();
 2117                   } finally {
 2118                       l.exit();
 2119                   }
 2120               } else synchronized (l) {
 2121                   l.enter();
 2122                   try {
 2123                       _dispose();
 2124                   } finally {
 2125                       l.exit();
 2126                   }
 2127               }
 2128           }
 2129       }
 2130   
 2131       public Object monitor() {
 2132           if (preCheck()) {
 2133               _cur._locale.enter();
 2134               try {
 2135                   return _monitor();
 2136               } finally {
 2137                   _cur._locale.exit();
 2138               }
 2139           } else synchronized (_cur._locale) {
 2140               _cur._locale.enter();
 2141               try {
 2142                   return _monitor();
 2143               } finally {
 2144                   _cur._locale.exit();
 2145               }
 2146           }
 2147       }
 2148   
 2149       public XmlDocumentProperties documentProperties() {
 2150           if (preCheck()) {
 2151               _cur._locale.enter();
 2152               try {
 2153                   return _documentProperties();
 2154               } finally {
 2155                   _cur._locale.exit();
 2156               }
 2157           } else synchronized (_cur._locale) {
 2158               _cur._locale.enter();
 2159               try {
 2160                   return _documentProperties();
 2161               } finally {
 2162                   _cur._locale.exit();
 2163               }
 2164           }
 2165       }
 2166   
 2167       public XmlCursor newCursor() {
 2168           if (preCheck()) {
 2169               _cur._locale.enter();
 2170               try {
 2171                   return _newCursor();
 2172               } finally {
 2173                   _cur._locale.exit();
 2174               }
 2175           } else synchronized (_cur._locale) {
 2176               _cur._locale.enter();
 2177               try {
 2178                   return _newCursor();
 2179               } finally {
 2180                   _cur._locale.exit();
 2181               }
 2182           }
 2183       }
 2184   
 2185       public XMLStreamReader newXMLStreamReader() {
 2186           if (preCheck()) {
 2187               _cur._locale.enter();
 2188               try {
 2189                   return _newXMLStreamReader();
 2190               } finally {
 2191                   _cur._locale.exit();
 2192               }
 2193           } else synchronized (_cur._locale) {
 2194               _cur._locale.enter();
 2195               try {
 2196                   return _newXMLStreamReader();
 2197               } finally {
 2198                   _cur._locale.exit();
 2199               }
 2200           }
 2201       }
 2202   
 2203       public XMLStreamReader newXMLStreamReader(XmlOptions options) {
 2204           if (preCheck()) {
 2205               _cur._locale.enter();
 2206               try {
 2207                   return _newXMLStreamReader(options);
 2208               } finally {
 2209                   _cur._locale.exit();
 2210               }
 2211           } else synchronized (_cur._locale) {
 2212               _cur._locale.enter();
 2213               try {
 2214                   return _newXMLStreamReader(options);
 2215               } finally {
 2216                   _cur._locale.exit();
 2217               }
 2218           }
 2219       }
 2220   
 2221       /**
 2222        * @deprecated XMLInputStream was deprecated by XMLStreamReader from STaX - jsr173 API.
 2223        */
 2224       public XMLInputStream newXMLInputStream() {
 2225           if (preCheck()) {
 2226               _cur._locale.enter();
 2227               try {
 2228                   return _newXMLInputStream();
 2229               } finally {
 2230                   _cur._locale.exit();
 2231               }
 2232           } else synchronized (_cur._locale) {
 2233               _cur._locale.enter();
 2234               try {
 2235                   return _newXMLInputStream();
 2236               } finally {
 2237                   _cur._locale.exit();
 2238               }
 2239           }
 2240       }
 2241   
 2242       public String xmlText() {
 2243           if (preCheck()) {
 2244               _cur._locale.enter();
 2245               try {
 2246                   return _xmlText();
 2247               } finally {
 2248                   _cur._locale.exit();
 2249               }
 2250           } else synchronized (_cur._locale) {
 2251               _cur._locale.enter();
 2252               try {
 2253                   return _xmlText();
 2254               } finally {
 2255                   _cur._locale.exit();
 2256               }
 2257           }
 2258       }
 2259   
 2260       public InputStream newInputStream() {
 2261           if (preCheck()) {
 2262               _cur._locale.enter();
 2263               try {
 2264                   return _newInputStream();
 2265               } finally {
 2266                   _cur._locale.exit();
 2267               }
 2268           } else synchronized (_cur._locale) {
 2269               _cur._locale.enter();
 2270               try {
 2271                   return _newInputStream();
 2272               } finally {
 2273                   _cur._locale.exit();
 2274               }
 2275           }
 2276       }
 2277   
 2278       public Reader newReader() {
 2279           if (preCheck()) {
 2280               _cur._locale.enter();
 2281               try {
 2282                   return _newReader();
 2283               } finally {
 2284                   _cur._locale.exit();
 2285               }
 2286           } else synchronized (_cur._locale) {
 2287               _cur._locale.enter();
 2288               try {
 2289                   return _newReader();
 2290               } finally {
 2291                   _cur._locale.exit();
 2292               }
 2293           }
 2294       }
 2295   
 2296       public Node newDomNode() {
 2297           if (preCheck()) {
 2298               _cur._locale.enter();
 2299               try {
 2300                   return _newDomNode();
 2301               } finally {
 2302                   _cur._locale.exit();
 2303               }
 2304           } else synchronized (_cur._locale) {
 2305               _cur._locale.enter();
 2306               try {
 2307                   return _newDomNode();
 2308               } finally {
 2309                   _cur._locale.exit();
 2310               }
 2311           }
 2312       }
 2313   
 2314       public Node getDomNode() {
 2315           if (preCheck()) {
 2316               _cur._locale.enter();
 2317               try {
 2318                   return _getDomNode();
 2319               } finally {
 2320                   _cur._locale.exit();
 2321               }
 2322           } else synchronized (_cur._locale) {
 2323               _cur._locale.enter();
 2324               try {
 2325                   return _getDomNode();
 2326               } finally {
 2327                   _cur._locale.exit();
 2328               }
 2329           }
 2330       }
 2331   
 2332       public void save(ContentHandler ch, LexicalHandler lh) throws SAXException {
 2333           if (preCheck()) {
 2334               _cur._locale.enter();
 2335               try {
 2336                   _save(ch, lh);
 2337               } finally {
 2338                   _cur._locale.exit();
 2339               }
 2340           } else synchronized (_cur._locale) {
 2341               _cur._locale.enter();
 2342               try {
 2343                   _save(ch, lh);
 2344               } finally {
 2345                   _cur._locale.exit();
 2346               }
 2347           }
 2348       }
 2349   
 2350       public void save(File file) throws IOException {
 2351           if (preCheck()) {
 2352               _cur._locale.enter();
 2353               try {
 2354                   _save(file);
 2355               } finally {
 2356                   _cur._locale.exit();
 2357               }
 2358           } else synchronized (_cur._locale) {
 2359               _cur._locale.enter();
 2360               try {
 2361                   _save(file);
 2362               } finally {
 2363                   _cur._locale.exit();
 2364               }
 2365           }
 2366       }
 2367   
 2368       public void save(OutputStream os) throws IOException {
 2369           if (preCheck()) {
 2370               _cur._locale.enter();
 2371               try {
 2372                   _save(os);
 2373               } finally {
 2374                   _cur._locale.exit();
 2375               }
 2376           } else synchronized (_cur._locale) {
 2377               _cur._locale.enter();
 2378               try {
 2379                   _save(os);
 2380               } finally {
 2381                   _cur._locale.exit();
 2382               }
 2383           }
 2384       }
 2385   
 2386       public void save(Writer w) throws IOException {
 2387           if (preCheck()) {
 2388               _cur._locale.enter();
 2389               try {
 2390                   _save(w);
 2391               } finally {
 2392                   _cur._locale.exit();
 2393               }
 2394           } else synchronized (_cur._locale) {
 2395               _cur._locale.enter();
 2396               try {
 2397                   _save(w);
 2398               } finally {
 2399                   _cur._locale.exit();
 2400               }
 2401           }
 2402       }
 2403   
 2404       /**
 2405        * @deprecated XMLInputStream was deprecated by XMLStreamReader from STaX - jsr173 API.
 2406        */
 2407       public XMLInputStream newXMLInputStream(XmlOptions options) {
 2408           if (preCheck()) {
 2409               _cur._locale.enter();
 2410               try {
 2411                   return _newXMLInputStream(options);
 2412               } finally {
 2413                   _cur._locale.exit();
 2414               }
 2415           } else synchronized (_cur._locale) {
 2416               _cur._locale.enter();
 2417               try {
 2418                   return _newXMLInputStream(options);
 2419               } finally {
 2420                   _cur._locale.exit();
 2421               }
 2422           }
 2423       }
 2424   
 2425       public String xmlText(XmlOptions options) {
 2426           if (preCheck()) {
 2427               _cur._locale.enter();
 2428               try {
 2429                   return _xmlText(options);
 2430               } finally {
 2431                   _cur._locale.exit();
 2432               }
 2433           } else synchronized (_cur._locale) {
 2434               _cur._locale.enter();
 2435               try {
 2436                   return _xmlText(options);
 2437               } finally {
 2438                   _cur._locale.exit();
 2439               }
 2440           }
 2441       }
 2442   
 2443       public InputStream newInputStream(XmlOptions options) {
 2444           if (preCheck()) {
 2445               _cur._locale.enter();
 2446               try {
 2447                   return _newInputStream(options);
 2448               } finally {
 2449                   _cur._locale.exit();
 2450               }
 2451           } else synchronized (_cur._locale) {
 2452               _cur._locale.enter();
 2453               try {
 2454                   return _newInputStream(options);
 2455               } finally {
 2456                   _cur._locale.exit();
 2457               }
 2458           }
 2459       }
 2460   
 2461       public Reader newReader(XmlOptions options) {
 2462           if (preCheck()) {
 2463               _cur._locale.enter();
 2464               try {
 2465                   return _newReader(options);
 2466               } finally {
 2467                   _cur._locale.exit();
 2468               }
 2469           } else synchronized (_cur._locale) {
 2470               _cur._locale.enter();
 2471               try {
 2472                   return _newReader(options);
 2473               } finally {
 2474                   _cur._locale.exit();
 2475               }
 2476           }
 2477       }
 2478   
 2479       public Node newDomNode(XmlOptions options) {
 2480           if (preCheck()) {
 2481               _cur._locale.enter();
 2482               try {
 2483                   return _newDomNode(options);
 2484               } finally {
 2485                   _cur._locale.exit();
 2486               }
 2487           } else synchronized (_cur._locale) {
 2488               _cur._locale.enter();
 2489               try {
 2490                   return _newDomNode(options);
 2491               } finally {
 2492                   _cur._locale.exit();
 2493               }
 2494           }
 2495       }
 2496   
 2497       public void save(ContentHandler ch, LexicalHandler lh, XmlOptions options) throws SAXException {
 2498           if (preCheck()) {
 2499               _cur._locale.enter();
 2500               try {
 2501                   _save(ch, lh, options);
 2502               } finally {
 2503                   _cur._locale.exit();
 2504               }
 2505           } else synchronized (_cur._locale) {
 2506               _cur._locale.enter();
 2507               try {
 2508                   _save(ch, lh, options);
 2509               } finally {
 2510                   _cur._locale.exit();
 2511               }
 2512           }
 2513       }
 2514   
 2515       public void save(File file, XmlOptions options) throws IOException {
 2516           if (preCheck()) {
 2517               _cur._locale.enter();
 2518               try {
 2519                   _save(file, options);
 2520               } finally {
 2521                   _cur._locale.exit();
 2522               }
 2523           } else synchronized (_cur._locale) {
 2524               _cur._locale.enter();
 2525               try {
 2526                   _save(file, options);
 2527               } finally {
 2528                   _cur._locale.exit();
 2529               }
 2530           }
 2531       }
 2532   
 2533       public void save(OutputStream os, XmlOptions options) throws IOException {
 2534           if (preCheck()) {
 2535               _cur._locale.enter();
 2536               try {
 2537                   _save(os, options);
 2538               } finally {
 2539                   _cur._locale.exit();
 2540               }
 2541           } else synchronized (_cur._locale) {
 2542               _cur._locale.enter();
 2543               try {
 2544                   _save(os, options);
 2545               } finally {
 2546                   _cur._locale.exit();
 2547               }
 2548           }
 2549       }
 2550   
 2551       public void save(Writer w, XmlOptions options) throws IOException {
 2552           if (preCheck()) {
 2553               _cur._locale.enter();
 2554               try {
 2555                   _save(w, options);
 2556               } finally {
 2557                   _cur._locale.exit();
 2558               }
 2559           } else synchronized (_cur._locale) {
 2560               _cur._locale.enter();
 2561               try {
 2562                   _save(w, options);
 2563               } finally {
 2564                   _cur._locale.exit();
 2565               }
 2566           }
 2567       }
 2568   
 2569       public void push() {
 2570           if (preCheck()) {
 2571               _cur._locale.enter();
 2572               try {
 2573                   _push();
 2574               } finally {
 2575                   _cur._locale.exit();
 2576               }
 2577           } else synchronized (_cur._locale) {
 2578               _cur._locale.enter();
 2579               try {
 2580                   _push();
 2581               } finally {
 2582                   _cur._locale.exit();
 2583               }
 2584           }
 2585       }
 2586   
 2587       public boolean pop() {
 2588           if (preCheck()) {
 2589               _cur._locale.enter();
 2590               try {
 2591                   return _pop();
 2592               } finally {
 2593                   _cur._locale.exit();
 2594               }
 2595           } else synchronized (_cur._locale) {
 2596               _cur._locale.enter();
 2597               try {
 2598                   return _pop();
 2599               } finally {
 2600                   _cur._locale.exit();
 2601               }
 2602           }
 2603       }
 2604   
 2605       public void selectPath(String path) {
 2606           if (preCheck()) {
 2607               _cur._locale.enter();
 2608               try {
 2609                   _selectPath(path);
 2610               } finally {
 2611                   _cur._locale.exit();
 2612               }
 2613           } else synchronized (_cur._locale) {
 2614               _cur._locale.enter();
 2615               try {
 2616                   _selectPath(path);
 2617               } finally {
 2618                   _cur._locale.exit();
 2619               }
 2620           }
 2621       }
 2622   
 2623       public void selectPath(String path, XmlOptions options) {
 2624           if (preCheck()) {
 2625               _cur._locale.enter();
 2626               try {
 2627                   _selectPath(path, options);
 2628               } finally {
 2629                   _cur._locale.exit();
 2630               }
 2631           } else synchronized (_cur._locale) {
 2632               _cur._locale.enter();
 2633               try {
 2634                   _selectPath(path, options);
 2635               } finally {
 2636                   _cur._locale.exit();
 2637               }
 2638           }
 2639       }
 2640   
 2641       public boolean hasNextSelection() {
 2642           if (preCheck()) {
 2643               _cur._locale.enter();
 2644               try {
 2645                   return _hasNextSelection();
 2646               } finally {
 2647                   _cur._locale.exit();
 2648               }
 2649           } else synchronized (_cur._locale) {
 2650               _cur._locale.enter();
 2651               try {
 2652                   return _hasNextSelection();
 2653               } finally {
 2654                   _cur._locale.exit();
 2655               }
 2656           }
 2657       }
 2658   
 2659       public boolean toNextSelection() {
 2660           if (preCheck()) {
 2661               _cur._locale.enter();
 2662               try {
 2663                   return _toNextSelection();
 2664               } finally {
 2665                   _cur._locale.exit();
 2666               }
 2667           } else synchronized (_cur._locale) {
 2668               _cur._locale.enter();
 2669               try {
 2670                   return _toNextSelection();
 2671               } finally {
 2672                   _cur._locale.exit();
 2673               }
 2674           }
 2675       }
 2676   
 2677       public boolean toSelection(int i) {
 2678           if (preCheck()) {
 2679               _cur._locale.enter();
 2680               try {
 2681                   return _toSelection(i);
 2682               } finally {
 2683                   _cur._locale.exit();
 2684               }
 2685           } else synchronized (_cur._locale) {
 2686               _cur._locale.enter();
 2687               try {
 2688                   return _toSelection(i);
 2689               } finally {
 2690                   _cur._locale.exit();
 2691               }
 2692           }
 2693       }
 2694   
 2695       public int getSelectionCount() {
 2696           if (preCheck()) {
 2697               _cur._locale.enter();
 2698               try {
 2699                   return _getSelectionCount();
 2700               } finally {
 2701                   _cur._locale.exit();
 2702               }
 2703           } else synchronized (_cur._locale) {
 2704               _cur._locale.enter();
 2705               try {
 2706                   return _getSelectionCount();
 2707               } finally {
 2708                   _cur._locale.exit();
 2709               }
 2710           }
 2711       }
 2712   
 2713       public void addToSelection() {
 2714           if (preCheck()) {
 2715               _cur._locale.enter();
 2716               try {
 2717                   _addToSelection();
 2718               } finally {
 2719                   _cur._locale.exit();
 2720               }
 2721           } else synchronized (_cur._locale) {
 2722               _cur._locale.enter();
 2723               try {
 2724                   _addToSelection();
 2725               } finally {
 2726                   _cur._locale.exit();
 2727               }
 2728           }
 2729       }
 2730   
 2731       public void clearSelections() {
 2732           if (preCheck()) {
 2733               _cur._locale.enter();
 2734               try {
 2735                   _clearSelections();
 2736               } finally {
 2737                   _cur._locale.exit();
 2738               }
 2739           } else synchronized (_cur._locale) {
 2740               _cur._locale.enter();
 2741               try {
 2742                   _clearSelections();
 2743               } finally {
 2744                   _cur._locale.exit();
 2745               }
 2746           }
 2747       }
 2748   
 2749       public boolean toBookmark(XmlBookmark bookmark) {
 2750           if (preCheck()) {
 2751               _cur._locale.enter();
 2752               try {
 2753                   return _toBookmark(bookmark);
 2754               } finally {
 2755                   _cur._locale.exit();
 2756               }
 2757           } else synchronized (_cur._locale) {
 2758               _cur._locale.enter();
 2759               try {
 2760                   return _toBookmark(bookmark);
 2761               } finally {
 2762                   _cur._locale.exit();
 2763               }
 2764           }
 2765       }
 2766   
 2767       public XmlBookmark toNextBookmark(Object key) {
 2768           if (preCheck()) {
 2769               _cur._locale.enter();
 2770               try {
 2771                   return _toNextBookmark(key);
 2772               } finally {
 2773                   _cur._locale.exit();
 2774               }
 2775           } else synchronized (_cur._locale) {
 2776               _cur._locale.enter();
 2777               try {
 2778                   return _toNextBookmark(key);
 2779               } finally {
 2780                   _cur._locale.exit();
 2781               }
 2782           }
 2783       }
 2784   
 2785       public XmlBookmark toPrevBookmark(Object key) {
 2786           if (preCheck()) {
 2787               _cur._locale.enter();
 2788               try {
 2789                   return _toPrevBookmark(key);
 2790               } finally {
 2791                   _cur._locale.exit();
 2792               }
 2793           } else synchronized (_cur._locale) {
 2794               _cur._locale.enter();
 2795               try {
 2796                   return _toPrevBookmark(key);
 2797               } finally {
 2798                   _cur._locale.exit();
 2799               }
 2800           }
 2801       }
 2802   
 2803       public QName getName() {
 2804           if (preCheck()) {
 2805               _cur._locale.enter();
 2806               try {
 2807                   return _getName();
 2808               } finally {
 2809                   _cur._locale.exit();
 2810               }
 2811           } else synchronized (_cur._locale) {
 2812               _cur._locale.enter();
 2813               try {
 2814                   return _getName();
 2815               } finally {
 2816                   _cur._locale.exit();
 2817               }
 2818           }
 2819       }
 2820   
 2821       public void setName(QName name) {
 2822           if (preCheck()) {
 2823               _cur._locale.enter();
 2824               try {
 2825                   _setName(name);
 2826               } finally {
 2827                   _cur._locale.exit();
 2828               }
 2829           } else synchronized (_cur._locale) {
 2830               _cur._locale.enter();
 2831               try {
 2832                   _setName(name);
 2833               } finally {
 2834                   _cur._locale.exit();
 2835               }
 2836           }
 2837       }
 2838   
 2839       public String namespaceForPrefix(String prefix) {
 2840           if (preCheck()) {
 2841               _cur._locale.enter();
 2842               try {
 2843                   return _namespaceForPrefix(prefix);
 2844               } finally {
 2845                   _cur._locale.exit();
 2846               }
 2847           } else synchronized (_cur._locale) {
 2848               _cur._locale.enter();
 2849               try {
 2850                   return _namespaceForPrefix(prefix);
 2851               } finally {
 2852                   _cur._locale.exit();
 2853               }
 2854           }
 2855       }
 2856   
 2857       public String prefixForNamespace(String namespaceURI) {
 2858           if (preCheck()) {
 2859               _cur._locale.enter();
 2860               try {
 2861                   return _prefixForNamespace(namespaceURI);
 2862               } finally {
 2863                   _cur._locale.exit();
 2864               }
 2865           } else synchronized (_cur._locale) {
 2866               _cur._locale.enter();
 2867               try {
 2868                   return _prefixForNamespace(namespaceURI);
 2869               } finally {
 2870                   _cur._locale.exit();
 2871               }
 2872           }
 2873       }
 2874   
 2875       public void getAllNamespaces(Map addToThis) {
 2876           if (preCheck()) {
 2877               _cur._locale.enter();
 2878               try {
 2879                   _getAllNamespaces(addToThis);
 2880               } finally {
 2881                   _cur._locale.exit();
 2882               }
 2883           } else synchronized (_cur._locale) {
 2884               _cur._locale.enter();
 2885               try {
 2886                   _getAllNamespaces(addToThis);
 2887               } finally {
 2888                   _cur._locale.exit();
 2889               }
 2890           }
 2891       }
 2892   
 2893       public XmlObject getObject() {
 2894           if (preCheck()) {
 2895               _cur._locale.enter();
 2896               try {
 2897                   return _getObject();
 2898               } finally {
 2899                   _cur._locale.exit();
 2900               }
 2901           } else synchronized (_cur._locale) {
 2902               _cur._locale.enter();
 2903               try {
 2904                   return _getObject();
 2905               } finally {
 2906                   _cur._locale.exit();
 2907               }
 2908           }
 2909       }
 2910   
 2911       public TokenType currentTokenType() {
 2912           if (preCheck()) {
 2913   //            _cur._locale.enter();
 2914   //            try {
 2915                   return _currentTokenType();
 2916   //            } finally {
 2917   //                _cur._locale.exit();
 2918   //            }
 2919           } else synchronized (_cur._locale) {
 2920   //            _cur._locale.enter();
 2921   //            try {
 2922                   return _currentTokenType();
 2923   //            } finally {
 2924   //                _cur._locale.exit();
 2925   //            }
 2926           }
 2927       }
 2928   
 2929       public boolean isStartdoc() {
 2930           if (preCheck()) {
 2931   //            _cur._locale.enter();
 2932   //            try {
 2933                   return _isStartdoc();
 2934   //            } finally {
 2935   //                _cur._locale.exit();
 2936   //            }
 2937           } else synchronized (_cur._locale) {
 2938   //            _cur._locale.enter();
 2939   //            try {
 2940                   return _isStartdoc();
 2941   //            } finally {
 2942   //                _cur._locale.exit();
 2943   //            }
 2944           }
 2945       }
 2946   
 2947       public boolean isEnddoc() {
 2948           if (preCheck()) {
 2949   //            _cur._locale.enter();
 2950   //            try {
 2951                   return _isEnddoc();
 2952   //            } finally {
 2953   //                _cur._locale.exit();
 2954   //            }
 2955           } else synchronized (_cur._locale) {
 2956   //            _cur._locale.enter();
 2957   //            try {
 2958                   return _isEnddoc();
 2959   //            } finally {
 2960   //                _cur._locale.exit();
 2961   //            }
 2962           }
 2963       }
 2964   
 2965       public boolean isStart() {
 2966           if (preCheck()) {
 2967   //            _cur._locale.enter();
 2968   //            try {
 2969                   return _isStart();
 2970   //            } finally {
 2971   //                _cur._locale.exit();
 2972   //            }
 2973           } else synchronized (_cur._locale) {
 2974   //            _cur._locale.enter();
 2975   //            try {
 2976                   return _isStart();
 2977   //            } finally {
 2978   //                _cur._locale.exit();
 2979   //            }
 2980           }
 2981       }
 2982   
 2983       public boolean isEnd() {
 2984           if (preCheck()) {
 2985   //            _cur._locale.enter();
 2986   //            try {
 2987                   return _isEnd();
 2988   //            } finally {
 2989   //                _cur._locale.exit();
 2990   //            }
 2991           } else synchronized (_cur._locale) {
 2992   //            _cur._locale.enter();
 2993   //            try {
 2994                   return _isEnd();
 2995   //            } finally {
 2996   //                _cur._locale.exit();
 2997   //            }
 2998           }
 2999       }
 3000   
 3001       public boolean isText() {
 3002           if (preCheck()) {
 3003   //            _cur._locale.enter();
 3004   //            try {
 3005                   return _isText();
 3006   //            } finally {
 3007   //                _cur._locale.exit();
 3008   //            }
 3009           } else synchronized (_cur._locale) {
 3010   //            _cur._locale.enter();
 3011   //            try {
 3012                   return _isText();
 3013   //            } finally {
 3014   //                _cur._locale.exit();
 3015   //            }
 3016           }
 3017       }
 3018   
 3019       public boolean isAttr() {
 3020           if (preCheck()) {
 3021   //            _cur._locale.enter();
 3022   //            try {
 3023                   return _isAttr();
 3024   //            } finally {
 3025   //                _cur._locale.exit();
 3026   //            }
 3027           } else synchronized (_cur._locale) {
 3028   //            _cur._locale.enter();
 3029   //            try {
 3030                   return _isAttr();
 3031   //            } finally {
 3032   //                _cur._locale.exit();
 3033   //            }
 3034           }
 3035       }
 3036   
 3037       public boolean isNamespace() {
 3038           if (preCheck()) {
 3039   //            _cur._locale.enter();
 3040   //            try {
 3041                   return _isNamespace();
 3042   //            } finally {
 3043   //                _cur._locale.exit();
 3044   //            }
 3045           } else synchronized (_cur._locale) {
 3046   //            _cur._locale.enter();
 3047   //            try {
 3048                   return _isNamespace();
 3049   //            } finally {
 3050   //                _cur._locale.exit();
 3051   //            }
 3052           }
 3053       }
 3054   
 3055       public boolean isComment() {
 3056           if (preCheck()) {
 3057   //            _cur._locale.enter();
 3058   //            try {
 3059                   return _isComment();
 3060   //            } finally {
 3061   //                _cur._locale.exit();
 3062   //            }
 3063           } else synchronized (_cur._locale) {
 3064   //            _cur._locale.enter();
 3065   //            try {
 3066                   return _isComment();
 3067   //            } finally {
 3068   //                _cur._locale.exit();
 3069   //            }
 3070           }
 3071       }
 3072   
 3073       public boolean isProcinst() {
 3074           if (preCheck()) {
 3075   //            _cur._locale.enter();
 3076   //            try {
 3077                   return _isProcinst();
 3078   //            } finally {
 3079   //                _cur._locale.exit();
 3080   //            }
 3081           } else synchronized (_cur._locale) {
 3082   //            _cur._locale.enter();
 3083   //            try {
 3084                   return _isProcinst();
 3085   //            } finally {
 3086   //                _cur._locale.exit();
 3087   //            }
 3088           }
 3089       }
 3090   
 3091       public boolean isContainer() {
 3092           if (preCheck()) {
 3093   //            _cur._locale.enter();
 3094   //            try {
 3095                   return _isContainer();
 3096   //            } finally {
 3097   //                _cur._locale.exit();
 3098   //            }
 3099           } else synchronized (_cur._locale) {
 3100   //            _cur._locale.enter();
 3101   //            try {
 3102                   return _isContainer();
 3103   //            } finally {
 3104   //                _cur._locale.exit();
 3105   //            }
 3106           }
 3107       }
 3108   
 3109       public boolean isFinish() {
 3110           if (preCheck()) {
 3111   //            _cur._locale.enter();
 3112   //            try {
 3113                   return _isFinish();
 3114   //            } finally {
 3115   //                _cur._locale.exit();
 3116   //            }
 3117           } else synchronized (_cur._locale) {
 3118   //            _cur._locale.enter();
 3119   //            try {
 3120                   return _isFinish();
 3121   //            } finally {
 3122   //                _cur._locale.exit();
 3123   //            }
 3124           }
 3125       }
 3126   
 3127       public boolean isAnyAttr() {
 3128           if (preCheck()) {
 3129   //            _cur._locale.enter();
 3130   //            try {
 3131                   return _isAnyAttr();
 3132   //            } finally {
 3133   //                _cur._locale.exit();
 3134   //            }
 3135           } else synchronized (_cur._locale) {
 3136   //            _cur._locale.enter();
 3137   //            try {
 3138                   return _isAnyAttr();
 3139   //            } finally {
 3140   //                _cur._locale.exit();
 3141   //            }
 3142           }
 3143       }
 3144   
 3145       public TokenType prevTokenType() {
 3146           if (preCheck()) {
 3147               _cur._locale.enter();
 3148               try {
 3149                   return _prevTokenType();
 3150               } finally {
 3151                   _cur._locale.exit();
 3152               }
 3153           } else synchronized (_cur._locale) {
 3154               _cur._locale.enter();
 3155               try {
 3156                   return _prevTokenType();
 3157               } finally {
 3158                   _cur._locale.exit();
 3159               }
 3160           }
 3161       }
 3162   
 3163       public boolean hasNextToken() {
 3164           if (preCheck()) {
 3165   //            _cur._locale.enter();
 3166   //            try {
 3167                   return _hasNextToken();
 3168   //            } finally {
 3169   //                _cur._locale.exit();
 3170   //            }
 3171           } else synchronized (_cur._locale) {
 3172   //            _cur._locale.enter();
 3173   //            try {
 3174                   return _hasNextToken();
 3175   //            } finally {
 3176   //                _cur._locale.exit();
 3177   //            }
 3178           }
 3179       }
 3180   
 3181       public boolean hasPrevToken() {
 3182           if (preCheck()) {
 3183               _cur._locale.enter();
 3184               try {
 3185                   return _hasPrevToken();
 3186               } finally {
 3187                   _cur._locale.exit();
 3188               }
 3189           } else synchronized (_cur._locale) {
 3190               _cur._locale.enter();
 3191               try {
 3192                   return _hasPrevToken();
 3193               } finally {
 3194                   _cur._locale.exit();
 3195               }
 3196           }
 3197       }
 3198   
 3199       public TokenType toNextToken() {
 3200           if (preCheck()) {
 3201               _cur._locale.enter();
 3202               try {
 3203                   return _toNextToken();
 3204               } finally {
 3205                   _cur._locale.exit();
 3206               }
 3207           } else synchronized (_cur._locale) {
 3208               _cur._locale.enter();
 3209               try {
 3210                   return _toNextToken();
 3211               } finally {
 3212                   _cur._locale.exit();
 3213               }
 3214           }
 3215       }
 3216   
 3217       public TokenType toPrevToken() {
 3218           if (preCheck()) {
 3219               _cur._locale.enter();
 3220               try {
 3221                   return _toPrevToken();
 3222               } finally {
 3223                   _cur._locale.exit();
 3224               }
 3225           } else synchronized (_cur._locale) {
 3226               _cur._locale.enter();
 3227               try {
 3228                   return _toPrevToken();
 3229               } finally {
 3230                   _cur._locale.exit();
 3231               }
 3232           }
 3233       }
 3234   
 3235       public TokenType toFirstContentToken() {
 3236           if (preCheck()) {
 3237               _cur._locale.enter();
 3238               try {
 3239                   return _toFirstContentToken();
 3240               } finally {
 3241                   _cur._locale.exit();
 3242               }
 3243           } else synchronized (_cur._locale) {
 3244               _cur._locale.enter();
 3245               try {
 3246                   return _toFirstContentToken();
 3247               } finally {
 3248                   _cur._locale.exit();
 3249               }
 3250           }
 3251       }
 3252   
 3253       public TokenType toEndToken() {
 3254           if (preCheck()) {
 3255               _cur._locale.enter();
 3256               try {
 3257                   return _toEndToken();
 3258               } finally {
 3259                   _cur._locale.exit();
 3260               }
 3261           } else synchronized (_cur._locale) {
 3262               _cur._locale.enter();
 3263               try {
 3264                   return _toEndToken();
 3265               } finally {
 3266                   _cur._locale.exit();
 3267               }
 3268           }
 3269       }
 3270   
 3271       public int toNextChar(int cch) {
 3272           if (preCheck()) {
 3273               _cur._locale.enter();
 3274               try {
 3275                   return _toNextChar(cch);
 3276               } finally {
 3277                   _cur._locale.exit();
 3278               }
 3279           } else synchronized (_cur._locale) {
 3280               _cur._locale.enter();
 3281               try {
 3282                   return _toNextChar(cch);
 3283               } finally {
 3284                   _cur._locale.exit();
 3285               }
 3286           }
 3287       }
 3288   
 3289       public int toPrevChar(int cch) {
 3290           if (preCheck()) {
 3291               _cur._locale.enter();
 3292               try {
 3293                   return _toPrevChar(cch);
 3294               } finally {
 3295                   _cur._locale.exit();
 3296               }
 3297           } else synchronized (_cur._locale) {
 3298               _cur._locale.enter();
 3299               try {
 3300                   return _toPrevChar(cch);
 3301               } finally {
 3302                   _cur._locale.exit();
 3303               }
 3304           }
 3305       }
 3306   
 3307   //    public boolean _toNextSibling()
 3308   //    {
 3309   //        return Locale.toNextSiblingElement(_cur);
 3310   //    }
 3311   
 3312       public boolean ___toNextSibling()
 3313       {
 3314           if (!_cur.hasParent())
 3315               return false;
 3316   
 3317           Xobj parent = _cur.getParentNoRoot();
 3318   
 3319           if (parent==null)
 3320           {
 3321               _cur._locale.enter();
 3322               try
 3323               {
 3324                   parent = _cur.getParent();
 3325               } finally {
 3326                   _cur._locale.exit();
 3327               }
 3328           }
 3329   
 3330           return Locale.toNextSiblingElement(_cur, parent);
 3331       }
 3332   
 3333       public boolean toNextSibling()
 3334       {
 3335           if (preCheck()) {
 3336               return ___toNextSibling();
 3337           } else synchronized (_cur._locale) {
 3338               return ___toNextSibling();
 3339           }
 3340       }
 3341   
 3342       public boolean toPrevSibling() {
 3343           if (preCheck()) {
 3344               _cur._locale.enter();
 3345               try {
 3346                   return _toPrevSibling();
 3347               } finally {
 3348                   _cur._locale.exit();
 3349               }
 3350           } else synchronized (_cur._locale) {
 3351               _cur._locale.enter();
 3352               try {
 3353                   return _toPrevSibling();
 3354               } finally {
 3355                   _cur._locale.exit();
 3356               }
 3357           }
 3358       }
 3359   
 3360       public boolean toParent() {
 3361           if (preCheck()) {
 3362               _cur._locale.enter();
 3363               try {
 3364                   return _toParent();
 3365               } finally {
 3366                   _cur._locale.exit();
 3367               }
 3368           } else synchronized (_cur._locale) {
 3369               _cur._locale.enter();
 3370               try {
 3371                   return _toParent();
 3372               } finally {
 3373                   _cur._locale.exit();
 3374               }
 3375           }
 3376       }
 3377   
 3378       public boolean toFirstChild() {
 3379           if (preCheck()) {
 3380   //            _cur._locale.enter();
 3381   //            try {
 3382                   return _toFirstChild();
 3383   //            } finally {
 3384   //                _cur._locale.exit();
 3385   //            }
 3386           } else synchronized (_cur._locale) {
 3387   //            _cur._locale.enter();
 3388   //            try {
 3389                   return _toFirstChild();
 3390   //            } finally {
 3391   //                _cur._locale.exit();
 3392   //            }
 3393           }
 3394       }
 3395   
 3396       public boolean toLastChild() {
 3397           if (preCheck()) {
 3398               _cur._locale.enter();
 3399               try {
 3400                   return _toLastChild();
 3401               } finally {
 3402                   _cur._locale.exit();
 3403               }
 3404           } else synchronized (_cur._locale) {
 3405               _cur._locale.enter();
 3406               try {
 3407                   return _toLastChild();
 3408               } finally {
 3409                   _cur._locale.exit();
 3410               }
 3411           }
 3412       }
 3413   
 3414       public boolean toChild(String name) {
 3415           if (preCheck()) {
 3416               _cur._locale.enter();
 3417               try {
 3418                   return _toChild(name);
 3419               } finally {
 3420                   _cur._locale.exit();
 3421               }
 3422           } else synchronized (_cur._locale) {
 3423               _cur._locale.enter();
 3424               try {
 3425                   return _toChild(name);
 3426               } finally {
 3427                   _cur._locale.exit();
 3428               }
 3429           }
 3430       }
 3431   
 3432       public boolean toChild(String namespace, String name) {
 3433           if (preCheck()) {
 3434               _cur._locale.enter();
 3435               try {
 3436                   return _toChild(namespace, name);
 3437               } finally {
 3438                   _cur._locale.exit();
 3439               }
 3440           } else synchronized (_cur._locale) {
 3441               _cur._locale.enter();
 3442               try {
 3443                   return _toChild(namespace, name);
 3444               } finally {
 3445                   _cur._locale.exit();
 3446               }
 3447           }
 3448       }
 3449   
 3450       public boolean toChild(QName name) {
 3451           if (preCheck()) {
 3452               _cur._locale.enter();
 3453               try {
 3454                   return _toChild(name);
 3455               } finally {
 3456                   _cur._locale.exit();
 3457               }
 3458           } else synchronized (_cur._locale) {
 3459               _cur._locale.enter();
 3460               try {
 3461                   return _toChild(name);
 3462               } finally {
 3463                   _cur._locale.exit();
 3464               }
 3465           }
 3466       }
 3467   
 3468       public boolean toChild(int index) {
 3469           if (preCheck()) {
 3470               _cur._locale.enter();
 3471               try {
 3472                   return _toChild(index);
 3473               } finally {
 3474                   _cur._locale.exit();
 3475               }
 3476           } else synchronized (_cur._locale) {
 3477               _cur._locale.enter();
 3478               try {
 3479                   return _toChild(index);
 3480               } finally {
 3481                   _cur._locale.exit();
 3482               }
 3483           }
 3484       }
 3485   
 3486       public boolean toChild(QName name, int index) {
 3487           if (preCheck()) {
 3488               _cur._locale.enter();
 3489               try {
 3490                   return _toChild(name, index);
 3491               } finally {
 3492                   _cur._locale.exit();
 3493               }
 3494           } else synchronized (_cur._locale) {
 3495               _cur._locale.enter();
 3496               try {
 3497                   return _toChild(name, index);
 3498               } finally {
 3499                   _cur._locale.exit();
 3500               }
 3501           }
 3502       }
 3503   
 3504       public boolean toNextSibling(String name) {
 3505           if (preCheck()) {
 3506               _cur._locale.enter();
 3507               try {
 3508                   return _toNextSibling(name);
 3509               } finally {
 3510                   _cur._locale.exit();
 3511               }
 3512           } else synchronized (_cur._locale) {
 3513               _cur._locale.enter();
 3514               try {
 3515                   return _toNextSibling(name);
 3516               } finally {
 3517                   _cur._locale.exit();
 3518               }
 3519           }
 3520       }
 3521   
 3522       public boolean toNextSibling(String namespace, String name) {
 3523           if (preCheck()) {
 3524               _cur._locale.enter();
 3525               try {
 3526                   return _toNextSibling(namespace, name);
 3527               } finally {
 3528                   _cur._locale.exit();
 3529               }
 3530           } else synchronized (_cur._locale) {
 3531               _cur._locale.enter();
 3532               try {
 3533                   return _toNextSibling(namespace, name);
 3534               } finally {
 3535                   _cur._locale.exit();
 3536               }
 3537           }
 3538       }
 3539   
 3540       public boolean toNextSibling(QName name) {
 3541           if (preCheck()) {
 3542               _cur._locale.enter();
 3543               try {
 3544                   return _toNextSibling(name);
 3545               } finally {
 3546                   _cur._locale.exit();
 3547               }
 3548           } else synchronized (_cur._locale) {
 3549               _cur._locale.enter();
 3550               try {
 3551                   return _toNextSibling(name);
 3552               } finally {
 3553                   _cur._locale.exit();
 3554               }
 3555           }
 3556       }
 3557   
 3558       public boolean toFirstAttribute() {
 3559           if (preCheck()) {
 3560   //            _cur._locale.enter();
 3561   //            try {
 3562                   return _toFirstAttribute();
 3563   //            } finally {
 3564   //                _cur._locale.exit();
 3565   //            }
 3566           } else synchronized (_cur._locale) {
 3567   //            _cur._locale.enter();
 3568   //            try {
 3569                   return _toFirstAttribute();
 3570   //            } finally {
 3571   //                _cur._locale.exit();
 3572   //            }
 3573           }
 3574       }
 3575   
 3576       public boolean toLastAttribute() {
 3577           if (preCheck()) {
 3578               _cur._locale.enter();
 3579               try {
 3580                   return _toLastAttribute();
 3581               } finally {
 3582                   _cur._locale.exit();
 3583               }
 3584           } else synchronized (_cur._locale) {
 3585               _cur._locale.enter();
 3586               try {
 3587                   return _toLastAttribute();
 3588               } finally {
 3589                   _cur._locale.exit();
 3590               }
 3591           }
 3592       }
 3593   
 3594       public boolean toNextAttribute() {
 3595           if (preCheck()) {
 3596               _cur._locale.enter();
 3597               try {
 3598                   return _toNextAttribute();
 3599               } finally {
 3600                   _cur._locale.exit();
 3601               }
 3602           } else synchronized (_cur._locale) {
 3603               _cur._locale.enter();
 3604               try {
 3605                   return _toNextAttribute();
 3606               } finally {
 3607                   _cur._locale.exit();
 3608               }
 3609           }
 3610       }
 3611   
 3612       public boolean toPrevAttribute() {
 3613           if (preCheck()) {
 3614               _cur._locale.enter();
 3615               try {
 3616                   return _toPrevAttribute();
 3617               } finally {
 3618                   _cur._locale.exit();
 3619               }
 3620           } else synchronized (_cur._locale) {
 3621               _cur._locale.enter();
 3622               try {
 3623                   return _toPrevAttribute();
 3624               } finally {
 3625                   _cur._locale.exit();
 3626               }
 3627           }
 3628       }
 3629   
 3630       public String getAttributeText(QName attrName) {
 3631           if (preCheck()) {
 3632               _cur._locale.enter();
 3633               try {
 3634                   return _getAttributeText(attrName);
 3635               } finally {
 3636                   _cur._locale.exit();
 3637               }
 3638           } else synchronized (_cur._locale) {
 3639               _cur._locale.enter();
 3640               try {
 3641                   return _getAttributeText(attrName);
 3642               } finally {
 3643                   _cur._locale.exit();
 3644               }
 3645           }
 3646       }
 3647   
 3648       public boolean setAttributeText(QName attrName, String value) {
 3649           if (preCheck()) {
 3650               _cur._locale.enter();
 3651               try {
 3652                   return _setAttributeText(attrName, value);
 3653               } finally {
 3654                   _cur._locale.exit();
 3655               }
 3656           } else synchronized (_cur._locale) {
 3657               _cur._locale.enter();
 3658               try {
 3659                   return _setAttributeText(attrName, value);
 3660               } finally {
 3661                   _cur._locale.exit();
 3662               }
 3663           }
 3664       }
 3665   
 3666       public boolean removeAttribute(QName attrName) {
 3667           if (preCheck()) {
 3668               _cur._locale.enter();
 3669               try {
 3670                   return _removeAttribute(attrName);
 3671               } finally {
 3672                   _cur._locale.exit();
 3673               }
 3674           } else synchronized (_cur._locale) {
 3675               _cur._locale.enter();
 3676               try {
 3677                   return _removeAttribute(attrName);
 3678               } finally {
 3679                   _cur._locale.exit();
 3680               }
 3681           }
 3682       }
 3683   
 3684       public String getTextValue() {
 3685           if (preCheck()) {
 3686               _cur._locale.enter();
 3687               try {
 3688                   return _getTextValue();
 3689               } finally {
 3690                   _cur._locale.exit();
 3691               }
 3692           } else synchronized (_cur._locale) {
 3693               _cur._locale.enter();
 3694               try {
 3695                   return _getTextValue();
 3696               } finally {
 3697                   _cur._locale.exit();
 3698               }
 3699           }
 3700       }
 3701   
 3702       public int getTextValue(char[] chars, int offset, int cch) {
 3703           if (preCheck()) {
 3704               _cur._locale.enter();
 3705               try {
 3706                   return _getTextValue(chars, offset, cch);
 3707               } finally {
 3708                   _cur._locale.exit();
 3709               }
 3710           } else synchronized (_cur._locale) {
 3711               _cur._locale.enter();
 3712               try {
 3713                   return _getTextValue(chars, offset, cch);
 3714               } finally {
 3715                   _cur._locale.exit();
 3716               }
 3717           }
 3718       }
 3719   
 3720       public void setTextValue(String text) {
 3721           if (preCheck()) {
 3722               _cur._locale.enter();
 3723               try {
 3724                   _setTextValue(text);
 3725               } finally {
 3726                   _cur._locale.exit();
 3727               }
 3728           } else synchronized (_cur._locale) {
 3729               _cur._locale.enter();
 3730               try {
 3731                   _setTextValue(text);
 3732               } finally {
 3733                   _cur._locale.exit();
 3734               }
 3735           }
 3736       }
 3737   
 3738       public void setTextValue(char[] sourceChars, int offset, int length) {
 3739           if (preCheck()) {
 3740               _cur._locale.enter();
 3741               try {
 3742                   _setTextValue(sourceChars, offset, length);
 3743               } finally {
 3744                   _cur._locale.exit();
 3745               }
 3746           } else synchronized (_cur._locale) {
 3747               _cur._locale.enter();
 3748               try {
 3749                   _setTextValue(sourceChars, offset, length);
 3750               } finally {
 3751                   _cur._locale.exit();
 3752               }
 3753           }
 3754       }
 3755   
 3756       public String getChars() {
 3757           if (preCheck()) {
 3758               _cur._locale.enter();
 3759               try {
 3760                   return _getChars();
 3761               } finally {
 3762                   _cur._locale.exit();
 3763               }
 3764           } else synchronized (_cur._locale) {
 3765               _cur._locale.enter();
 3766               try {
 3767                   return _getChars();
 3768               } finally {
 3769                   _cur._locale.exit();
 3770               }
 3771           }
 3772       }
 3773   
 3774       public int getChars(char[] chars, int offset, int cch) {
 3775           if (preCheck()) {
 3776               _cur._locale.enter();
 3777               try {
 3778                   return _getChars(chars, offset, cch);
 3779               } finally {
 3780                   _cur._locale.exit();
 3781               }
 3782           } else synchronized (_cur._locale) {
 3783               _cur._locale.enter();
 3784               try {
 3785                   return _getChars(chars, offset, cch);
 3786               } finally {
 3787                   _cur._locale.exit();
 3788               }
 3789           }
 3790       }
 3791   
 3792       public void toStartDoc() {
 3793           if (preCheck()) {
 3794   //            _cur._locale.enter();
 3795   //            try {
 3796                   _toStartDoc();
 3797   //            } finally {
 3798   //                _cur._locale.exit();
 3799   //            }
 3800           } else synchronized (_cur._locale) {
 3801   //            _cur._locale.enter();
 3802   //            try {
 3803                   _toStartDoc();
 3804   //            } finally {
 3805   //                _cur._locale.exit();
 3806   //            }
 3807           }
 3808       }
 3809   
 3810       public void toEndDoc() {
 3811           if (preCheck()) {
 3812   //            _cur._locale.enter();
 3813   //            try {
 3814                   _toEndDoc();
 3815   //            } finally {
 3816   //                _cur._locale.exit();
 3817   //            }
 3818           } else synchronized (_cur._locale) {
 3819   //            _cur._locale.enter();
 3820   //            try {
 3821                   _toEndDoc();
 3822   //            } finally {
 3823   //                _cur._locale.exit();
 3824   //            }
 3825           }
 3826       }
 3827   
 3828       public XmlCursor execQuery(String query) {
 3829           if (preCheck()) {
 3830               _cur._locale.enter();
 3831               try {
 3832                   return _execQuery(query);
 3833               } finally {
 3834                   _cur._locale.exit();
 3835               }
 3836           } else synchronized (_cur._locale) {
 3837               _cur._locale.enter();
 3838               try {
 3839                   return _execQuery(query);
 3840               } finally {
 3841                   _cur._locale.exit();
 3842               }
 3843           }
 3844       }
 3845   
 3846       public XmlCursor execQuery(String query, XmlOptions options) {
 3847           if (preCheck()) {
 3848               _cur._locale.enter();
 3849               try {
 3850                   return _execQuery(query, options);
 3851               } finally {
 3852                   _cur._locale.exit();
 3853               }
 3854           } else synchronized (_cur._locale) {
 3855               _cur._locale.enter();
 3856               try {
 3857                   return _execQuery(query, options);
 3858               } finally {
 3859                   _cur._locale.exit();
 3860               }
 3861           }
 3862       }
 3863   
 3864       public ChangeStamp getDocChangeStamp() {
 3865           if (preCheck()) {
 3866               _cur._locale.enter();
 3867               try {
 3868                   return _getDocChangeStamp();
 3869               } finally {
 3870                   _cur._locale.exit();
 3871               }
 3872           } else synchronized (_cur._locale) {
 3873               _cur._locale.enter();
 3874               try {
 3875                   return _getDocChangeStamp();
 3876               } finally {
 3877                   _cur._locale.exit();
 3878               }
 3879           }
 3880       }
 3881   
 3882       public void setBookmark(XmlBookmark bookmark) {
 3883           if (preCheck()) {
 3884               _cur._locale.enter();
 3885               try {
 3886                   _setBookmark(bookmark);
 3887               } finally {
 3888                   _cur._locale.exit();
 3889               }
 3890           } else synchronized (_cur._locale) {
 3891               _cur._locale.enter();
 3892               try {
 3893                   _setBookmark(bookmark);
 3894               } finally {
 3895                   _cur._locale.exit();
 3896               }
 3897           }
 3898       }
 3899   
 3900       public XmlBookmark getBookmark(Object key) {
 3901           if (preCheck()) {
 3902               _cur._locale.enter();
 3903               try {
 3904                   return _getBookmark(key);
 3905               } finally {
 3906                   _cur._locale.exit();
 3907               }
 3908           } else synchronized (_cur._locale) {
 3909               _cur._locale.enter();
 3910               try {
 3911                   return _getBookmark(key);
 3912               } finally {
 3913                   _cur._locale.exit();
 3914               }
 3915           }
 3916       }
 3917   
 3918       public void clearBookmark(Object key) {
 3919           if (preCheck()) {
 3920               _cur._locale.enter();
 3921               try {
 3922                   _clearBookmark(key);
 3923               } finally {
 3924                   _cur._locale.exit();
 3925               }
 3926           } else synchronized (_cur._locale) {
 3927               _cur._locale.enter();
 3928               try {
 3929                   _clearBookmark(key);
 3930               } finally {
 3931                   _cur._locale.exit();
 3932               }
 3933           }
 3934       }
 3935   
 3936       public void getAllBookmarkRefs(Collection listToFill) {
 3937           if (preCheck()) {
 3938               _cur._locale.enter();
 3939               try {
 3940                   _getAllBookmarkRefs(listToFill);
 3941               } finally {
 3942                   _cur._locale.exit();
 3943               }
 3944           } else synchronized (_cur._locale) {
 3945               _cur._locale.enter();
 3946               try {
 3947                   _getAllBookmarkRefs(listToFill);
 3948               } finally {
 3949                   _cur._locale.exit();
 3950               }
 3951           }
 3952       }
 3953   
 3954       public boolean removeXml() {
 3955           if (preCheck()) {
 3956               _cur._locale.enter();
 3957               try {
 3958                   return _removeXml();
 3959               } finally {
 3960                   _cur._locale.exit();
 3961               }
 3962           } else synchronized (_cur._locale) {
 3963               _cur._locale.enter();
 3964               try {
 3965                   return _removeXml();
 3966               } finally {
 3967                   _cur._locale.exit();
 3968               }
 3969           }
 3970       }
 3971   
 3972       public boolean removeXmlContents() {
 3973           if (preCheck()) {
 3974               _cur._locale.enter();
 3975               try {
 3976                   return _removeXmlContents();
 3977               } finally {
 3978                   _cur._locale.exit();
 3979               }
 3980           } else synchronized (_cur._locale) {
 3981               _cur._locale.enter();
 3982               try {
 3983                   return _removeXmlContents();
 3984               } finally {
 3985                   _cur._locale.exit();
 3986               }
 3987           }
 3988       }
 3989   
 3990       public int removeChars(int cch) {
 3991           if (preCheck()) {
 3992               _cur._locale.enter();
 3993               try {
 3994                   return _removeChars(cch);
 3995               } finally {
 3996                   _cur._locale.exit();
 3997               }
 3998           } else synchronized (_cur._locale) {
 3999               _cur._locale.enter();
 4000               try {
 4001                   return _removeChars(cch);
 4002               } finally {
 4003                   _cur._locale.exit();
 4004               }
 4005           }
 4006       }
 4007   
 4008       public void insertChars(String text) {
 4009           if (preCheck()) {
 4010               _cur._locale.enter();
 4011               try {
 4012                   _insertChars(text);
 4013               } finally {
 4014                   _cur._locale.exit();
 4015               }
 4016           } else synchronized (_cur._locale) {
 4017               _cur._locale.enter();
 4018               try {
 4019                   _insertChars(text);
 4020               } finally {
 4021                   _cur._locale.exit();
 4022               }
 4023           }
 4024       }
 4025   
 4026       public void insertElement(QName name) {
 4027           if (preCheck()) {
 4028               _cur._locale.enter();
 4029               try {
 4030                   _insertElement(name);
 4031               } finally {
 4032                   _cur._locale.exit();
 4033               }
 4034           } else synchronized (_cur._locale) {
 4035               _cur._locale.enter();
 4036               try {
 4037                   _insertElement(name);
 4038               } finally {
 4039                   _cur._locale.exit();
 4040               }
 4041           }
 4042       }
 4043   
 4044       public void insertElement(String localName) {
 4045           if (preCheck()) {
 4046               _cur._locale.enter();
 4047               try {
 4048                   _insertElement(localName);
 4049               } finally {
 4050                   _cur._locale.exit();
 4051               }
 4052           } else synchronized (_cur._locale) {
 4053               _cur._locale.enter();
 4054               try {
 4055                   _insertElement(localName);
 4056               } finally {
 4057                   _cur._locale.exit();
 4058               }
 4059           }
 4060       }
 4061   
 4062       public void insertElement(String localName, String uri) {
 4063           if (preCheck()) {
 4064               _cur._locale.enter();
 4065               try {
 4066                   _insertElement(localName, uri);
 4067               } finally {
 4068                   _cur._locale.exit();
 4069               }
 4070           } else synchronized (_cur._locale) {
 4071               _cur._locale.enter();
 4072               try {
 4073                   _insertElement(localName, uri);
 4074               } finally {
 4075                   _cur._locale.exit();
 4076               }
 4077           }
 4078       }
 4079   
 4080       public void beginElement(QName name) {
 4081           if (preCheck()) {
 4082               _cur._locale.enter();
 4083               try {
 4084                   _beginElement(name);
 4085               } finally {
 4086                   _cur._locale.exit();
 4087               }
 4088           } else synchronized (_cur._locale) {
 4089               _cur._locale.enter();
 4090               try {
 4091                   _beginElement(name);
 4092               } finally {
 4093                   _cur._locale.exit();
 4094               }
 4095           }
 4096       }
 4097   
 4098       public void beginElement(String localName) {
 4099           if (preCheck()) {
 4100               _cur._locale.enter();
 4101               try {
 4102                   _beginElement(localName);
 4103               } finally {
 4104                   _cur._locale.exit();
 4105               }
 4106           } else synchronized (_cur._locale) {
 4107               _cur._locale.enter();
 4108               try {
 4109                   _beginElement(localName);
 4110               } finally {
 4111                   _cur._locale.exit();
 4112               }
 4113           }
 4114       }
 4115   
 4116       public void beginElement(String localName, String uri) {
 4117           if (preCheck()) {
 4118               _cur._locale.enter();
 4119               try {
 4120                   _beginElement(localName, uri);
 4121               } finally {
 4122                   _cur._locale.exit();
 4123               }
 4124           } else synchronized (_cur._locale) {
 4125               _cur._locale.enter();
 4126               try {
 4127                   _beginElement(localName, uri);
 4128               } finally {
 4129                   _cur._locale.exit();
 4130               }
 4131           }
 4132       }
 4133   
 4134       public void insertElementWithText(QName name, String text) {
 4135           if (preCheck()) {
 4136               _cur._locale.enter();
 4137               try {
 4138                   _insertElementWithText(name, text);
 4139               } finally {
 4140                   _cur._locale.exit();
 4141               }
 4142           } else synchronized (_cur._locale) {
 4143               _cur._locale.enter();
 4144               try {
 4145                   _insertElementWithText(name, text);
 4146               } finally {
 4147                   _cur._locale.exit();
 4148               }
 4149           }
 4150       }
 4151   
 4152       public void insertElementWithText(String localName, String text) {
 4153           if (preCheck()) {
 4154               _cur._locale.enter();
 4155               try {
 4156                   _insertElementWithText(localName, text);
 4157               } finally {
 4158                   _cur._locale.exit();
 4159               }
 4160           } else synchronized (_cur._locale) {
 4161               _cur._locale.enter();
 4162               try {
 4163                   _insertElementWithText(localName, text);
 4164               } finally {
 4165                   _cur._locale.exit();
 4166               }
 4167           }
 4168       }
 4169   
 4170       public void insertElementWithText(String localName, String uri, String text) {
 4171           if (preCheck()) {
 4172               _cur._locale.enter();
 4173               try {
 4174                   _insertElementWithText(localName, uri, text);
 4175               } finally {
 4176                   _cur._locale.exit();
 4177               }
 4178           } else synchronized (_cur._locale) {
 4179               _cur._locale.enter();
 4180               try {
 4181                   _insertElementWithText(localName, uri, text);
 4182               } finally {
 4183                   _cur._locale.exit();
 4184               }
 4185           }
 4186       }
 4187   
 4188       public void insertAttribute(String localName) {
 4189           if (preCheck()) {
 4190               _cur._locale.enter();
 4191               try {
 4192                   _insertAttribute(localName);
 4193               } finally {
 4194                   _cur._locale.exit();
 4195               }
 4196           } else synchronized (_cur._locale) {
 4197               _cur._locale.enter();
 4198               try {
 4199                   _insertAttribute(localName);
 4200               } finally {
 4201                   _cur._locale.exit();
 4202               }
 4203           }
 4204       }
 4205   
 4206       public void insertAttribute(String localName, String uri) {
 4207           if (preCheck()) {
 4208               _cur._locale.enter();
 4209               try {
 4210                   _insertAttribute(localName, uri);
 4211               } finally {
 4212                   _cur._locale.exit();
 4213               }
 4214           } else synchronized (_cur._locale) {
 4215               _cur._locale.enter();
 4216               try {
 4217                   _insertAttribute(localName, uri);
 4218               } finally {
 4219                   _cur._locale.exit();
 4220               }
 4221           }
 4222       }
 4223   
 4224       public void insertAttribute(QName name) {
 4225           if (preCheck()) {
 4226               _cur._locale.enter();
 4227               try {
 4228                   _insertAttribute(name);
 4229               } finally {
 4230                   _cur._locale.exit();
 4231               }
 4232           } else synchronized (_cur._locale) {
 4233               _cur._locale.enter();
 4234               try {
 4235                   _insertAttribute(name);
 4236               } finally {
 4237                   _cur._locale.exit();
 4238               }
 4239           }
 4240       }
 4241   
 4242       public void insertAttributeWithValue(String Name, String value) {
 4243           if (preCheck()) {
 4244               _cur._locale.enter();
 4245               try {
 4246                   _insertAttributeWithValue(Name, value);
 4247               } finally {
 4248                   _cur._locale.exit();
 4249               }
 4250           } else synchronized (_cur._locale) {
 4251               _cur._locale.enter();
 4252               try {
 4253                   _insertAttributeWithValue(Name, value);
 4254               } finally {
 4255                   _cur._locale.exit();
 4256               }
 4257           }
 4258       }
 4259   
 4260       public void insertAttributeWithValue(String name, String uri, String value) {
 4261           if (preCheck()) {
 4262               _cur._locale.enter();
 4263               try {
 4264                   _insertAttributeWithValue(name, uri, value);
 4265               } finally {
 4266                   _cur._locale.exit();
 4267               }
 4268           } else synchronized (_cur._locale) {
 4269               _cur._locale.enter();
 4270               try {
 4271                   _insertAttributeWithValue(name, uri, value);
 4272               } finally {
 4273                   _cur._locale.exit();
 4274               }
 4275           }
 4276       }
 4277   
 4278       public void insertAttributeWithValue(QName name, String value) {
 4279           if (preCheck()) {
 4280               _cur._locale.enter();
 4281               try {
 4282                   _insertAttributeWithValue(name, value);
 4283               } finally {
 4284                   _cur._locale.exit();
 4285               }
 4286           } else synchronized (_cur._locale) {
 4287               _cur._locale.enter();
 4288               try {
 4289                   _insertAttributeWithValue(name, value);
 4290               } finally {
 4291                   _cur._locale.exit();
 4292               }
 4293           }
 4294       }
 4295   
 4296       public void insertNamespace(String prefix, String namespace) {
 4297           if (preCheck()) {
 4298               _cur._locale.enter();
 4299               try {
 4300                   _insertNamespace(prefix, namespace);
 4301               } finally {
 4302                   _cur._locale.exit();
 4303               }
 4304           } else synchronized (_cur._locale) {
 4305               _cur._locale.enter();
 4306               try {
 4307                   _insertNamespace(prefix, namespace);
 4308               } finally {
 4309                   _cur._locale.exit();
 4310               }
 4311           }
 4312       }
 4313   
 4314       public void insertComment(String text) {
 4315           if (preCheck()) {
 4316               _cur._locale.enter();
 4317               try {
 4318                   _insertComment(text);
 4319               } finally {
 4320                   _cur._locale.exit();
 4321               }
 4322           } else synchronized (_cur._locale) {
 4323               _cur._locale.enter();
 4324               try {
 4325                   _insertComment(text);
 4326               } finally {
 4327                   _cur._locale.exit();
 4328               }
 4329           }
 4330       }
 4331   
 4332       public void insertProcInst(String target, String text) {
 4333           if (preCheck()) {
 4334               _cur._locale.enter();
 4335               try {
 4336                   _insertProcInst(target, text);
 4337               } finally {
 4338                   _cur._locale.exit();
 4339               }
 4340           } else synchronized (_cur._locale) {
 4341               _cur._locale.enter();
 4342               try {
 4343                   _insertProcInst(target, text);
 4344               } finally {
 4345                   _cur._locale.exit();
 4346               }
 4347           }
 4348       }
 4349   
 4350       public void dump() {
 4351           if (preCheck()) {
 4352               _cur._locale.enter();
 4353               try {
 4354                   _dump();
 4355               } finally {
 4356                   _cur._locale.exit();
 4357               }
 4358           } else synchronized (_cur._locale) {
 4359               _cur._locale.enter();
 4360               try {
 4361                   _dump();
 4362               } finally {
 4363                   _cur._locale.exit();
 4364               }
 4365           }
 4366       }
 4367       
 4368       //
 4369       //
 4370       //
 4371   
 4372       private Cur _cur;
 4373       private PathEngine _pathEngine;
 4374       private int _currentSelection;
 4375   
 4376       private ChangeListener _nextChangeListener;
 4377   }

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