src/com/sun/org/apache/xalan/internal/xsltc/dom/MultiDOM.java - platform/external/jetbrains/jdk8u_jaxp - Git at Google

 /*
  * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
  */
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.sun.org.apache.xalan.internal.xsltc.dom;

 import com.sun.org.apache.xalan.internal.xsltc.DOM;
 import com.sun.org.apache.xalan.internal.xsltc.StripFilter;
 import com.sun.org.apache.xalan.internal.xsltc.TransletException;
 import com.sun.org.apache.xalan.internal.xsltc.runtime.BasisLibrary;
 import com.sun.org.apache.xml.internal.dtm.Axis;
 import com.sun.org.apache.xml.internal.dtm.DTM;
 import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
 import com.sun.org.apache.xml.internal.dtm.DTMManager;
 import com.sun.org.apache.xml.internal.dtm.ref.DTMAxisIteratorBase;
 import com.sun.org.apache.xml.internal.dtm.ref.DTMAxisIterNodeList;
 import com.sun.org.apache.xml.internal.dtm.ref.DTMDefaultBase;
 import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
 import com.sun.org.apache.xml.internal.utils.SuballocatedIntVector;
 import java.util.HashMap;
 import java.util.Map;
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;

 /**
  * @author Jacek Ambroziak
  * @author Morten Jorgensen
  * @author Erwin Bolwidt <ejb@klomp.org>
  */
 public final class MultiDOM implements DOM {

     private static final int NO_TYPE = DOM.FIRST_TYPE - 2;
     private static final int INITIAL_SIZE = 4;

     private DOM[] _adapters;
     private DOMAdapter _main;
     private DTMManager _dtmManager;
     private int _free;
     private int _size;

     private Map<String, Integer> _documents = new HashMap<>();

     private final class AxisIterator extends DTMAxisIteratorBase {
         // constitutive data
         private final int _axis;
         private final int _type;
         // implementation mechanism
         private DTMAxisIterator _source;
         private int _dtmId = -1;

         public AxisIterator(final int axis, final int type) {
             _axis = axis;
             _type = type;
         }

         public int next() {
             if (_source == null) {
                 return(END);
             }
             return _source.next();
         }


         public void setRestartable(boolean flag) {
             if (_source != null) {
                 _source.setRestartable(flag);
             }
         }

         public DTMAxisIterator setStartNode(final int node) {
             if (node == DTM.NULL) {
                 return this;
             }

             int dom = node >>> DTMManager.IDENT_DTM_NODE_BITS;

             // Get a new source first time and when mask changes
             if (_source == null || _dtmId != dom) {
                 if (_type == NO_TYPE) {
                     _source = _adapters[dom].getAxisIterator(_axis);
                 } else if (_axis == Axis.CHILD) {
                     _source = _adapters[dom].getTypedChildren(_type);
                 } else {
                     _source = _adapters[dom].getTypedAxisIterator(_axis, _type);
                 }
             }

             _dtmId = dom;
             _source.setStartNode(node);
             return this;
         }

         public DTMAxisIterator reset() {
             if (_source != null) {
                 _source.reset();
             }
             return this;
         }

         public int getLast() {
             if (_source != null) {
                 return _source.getLast();
             }
             else {
                 return END;
             }
         }

         public int getPosition() {
             if (_source != null) {
                 return _source.getPosition();
             }
             else {
                 return END;
             }
         }

         public boolean isReverse() {
             return Axis.isReverse(_axis);
         }

         public void setMark() {
             if (_source != null) {
                 _source.setMark();
             }
         }

         public void gotoMark() {
             if (_source != null) {
                 _source.gotoMark();
             }
         }

         public DTMAxisIterator cloneIterator() {
             final AxisIterator clone = new AxisIterator(_axis, _type);
             if (_source != null) {
                 clone._source = _source.cloneIterator();
             }
             clone._dtmId = _dtmId;
             return clone;
         }
     } // end of AxisIterator


     /**************************************************************
      * This is a specialised iterator for predicates comparing node or
      * attribute values to variable or parameter values.
      */
     private final class NodeValueIterator extends DTMAxisIteratorBase {

         private DTMAxisIterator _source;
         private String _value;
         private boolean _op;
         private final boolean _isReverse;
         private int _returnType = RETURN_PARENT;

         public NodeValueIterator(DTMAxisIterator source, int returnType,
                                  String value, boolean op) {
             _source = source;
             _returnType = returnType;
             _value = value;
             _op = op;
             _isReverse = source.isReverse();
         }

         public boolean isReverse() {
             return _isReverse;
         }

         public DTMAxisIterator cloneIterator() {
             try {
                 NodeValueIterator clone = (NodeValueIterator)super.clone();
                 clone._source = _source.cloneIterator();
                 clone.setRestartable(false);
                 return clone.reset();
             }
             catch (CloneNotSupportedException e) {
                 BasisLibrary.runTimeError(BasisLibrary.ITERATOR_CLONE_ERR,
                                           e.toString());
                 return null;
             }
         }


         public void setRestartable(boolean isRestartable) {
             _isRestartable = isRestartable;
             _source.setRestartable(isRestartable);
         }

         public DTMAxisIterator reset() {
             _source.reset();
             return resetPosition();
         }

         public int next() {

             int node;
             while ((node = _source.next()) != END) {
                 String val = getStringValueX(node);
                 if (_value.equals(val) == _op) {
                     if (_returnType == RETURN_CURRENT)
                         return returnNode(node);
                     else
                         return returnNode(getParent(node));
                 }
             }
             return END;
         }

         public DTMAxisIterator setStartNode(int node) {
             if (_isRestartable) {
                 _source.setStartNode(_startNode = node);
                 return resetPosition();
             }
             return this;
         }

         public void setMark() {
             _source.setMark();
         }

         public void gotoMark() {
             _source.gotoMark();
         }
     }

     public MultiDOM(DOM main) {
         _size = INITIAL_SIZE;
         _free = 1;
         _adapters = new DOM[INITIAL_SIZE];
         DOMAdapter adapter = (DOMAdapter)main;
         _adapters[0] = adapter;
         _main = adapter;
         DOM dom = adapter.getDOMImpl();
         if (dom instanceof DTMDefaultBase) {
             _dtmManager = ((DTMDefaultBase)dom).getManager();
         }

         // %HZ% %REVISIT% Is this the right thing to do here?  In the old
         // %HZ% %REVISIT% version, the main document did not get added through
         // %HZ% %REVISIT% a call to addDOMAdapter, which meant it couldn't be
         // %HZ% %REVISIT% found by a call to getDocumentMask.  The problem is
         // %HZ% %REVISIT% TransformerHandler is typically constructed with a
         // %HZ% %REVISIT% system ID equal to the stylesheet's URI; with SAX
         // %HZ% %REVISIT% input, it ends up giving that URI to the document.
         // %HZ% %REVISIT% Then, any references to document('') are resolved
         // %HZ% %REVISIT% using the stylesheet's URI.
         // %HZ% %REVISIT% MultiDOM.getDocumentMask is called to verify that
         // %HZ% %REVISIT% a document associated with that URI has not been
         // %HZ% %REVISIT% encountered, and that method ends up returning the
         // %HZ% %REVISIT% mask of the main document, when what we really what
         // %HZ% %REVISIT% is to read the stylesheet itself!
         addDOMAdapter(adapter, false);
     }

     public int nextMask() {
         return _free;
     }

     public void setupMapping(String[] names, String[] uris, int[] types, String[] namespaces) {
         // This method only has a function in DOM adapters
     }

     public int addDOMAdapter(DOMAdapter adapter) {
         return addDOMAdapter(adapter, true);
     }

     private int addDOMAdapter(DOMAdapter adapter, boolean indexByURI) {
         // Add the DOM adapter to the array of DOMs
         DOM dom = adapter.getDOMImpl();

         int domNo = 1;
         int dtmSize = 1;
         SuballocatedIntVector dtmIds = null;
         if (dom instanceof DTMDefaultBase) {
             DTMDefaultBase dtmdb = (DTMDefaultBase)dom;
             dtmIds = dtmdb.getDTMIDs();
             dtmSize = dtmIds.size();
             domNo = dtmIds.elementAt(dtmSize-1) >>> DTMManager.IDENT_DTM_NODE_BITS;
         }
         else if (dom instanceof SimpleResultTreeImpl) {
             SimpleResultTreeImpl simpleRTF = (SimpleResultTreeImpl)dom;
             domNo = simpleRTF.getDocument() >>> DTMManager.IDENT_DTM_NODE_BITS;
         }

         if (domNo >= _size) {
             int oldSize = _size;
             do {
                 _size *= 2;
             } while (_size <= domNo);

             final DOMAdapter[] newArray = new DOMAdapter[_size];
             System.arraycopy(_adapters, 0, newArray, 0, oldSize);
             _adapters = newArray;
         }

         _free = domNo + 1;

         if (dtmSize == 1) {
             _adapters[domNo] = adapter;
         }
         else if (dtmIds != null) {
             int domPos = 0;
             for (int i = dtmSize - 1; i >= 0; i--) {
                 domPos = dtmIds.elementAt(i) >>> DTMManager.IDENT_DTM_NODE_BITS;
                 _adapters[domPos] = adapter;
             }
             domNo = domPos;
         }

         // Store reference to document (URI) in the Map
         if (indexByURI) {
             String uri = adapter.getDocumentURI(0);
             _documents.put(uri, domNo);
         }

         // If the dom is an AdaptiveResultTreeImpl, we need to create a
         // DOMAdapter around its nested dom object (if it is non-null) and
         // add the DOMAdapter to the list.
         if (dom instanceof AdaptiveResultTreeImpl) {
             AdaptiveResultTreeImpl adaptiveRTF = (AdaptiveResultTreeImpl)dom;
             DOM nestedDom = adaptiveRTF.getNestedDOM();
             if (nestedDom != null) {
                 DOMAdapter newAdapter = new DOMAdapter(nestedDom,
                                                        adapter.getNamesArray(),
                                                        adapter.getUrisArray(),
                                                        adapter.getTypesArray(),
                                                        adapter.getNamespaceArray());
                 addDOMAdapter(newAdapter);
             }
         }

         return domNo;
     }

     public int getDocumentMask(String uri) {
         Integer domIdx = _documents.get(uri);
         if (domIdx == null) {
             return(-1);
         } else {
             return domIdx.intValue();
         }
     }

     public DOM getDOMAdapter(String uri) {
         Integer domIdx = _documents.get(uri);
         if (domIdx == null) {
             return(null);
         } else {
             return(_adapters[domIdx.intValue()]);
         }
     }

     public int getDocument()
     {
         return _main.getDocument();
     }

     public DTMManager getDTMManager() {
         return _dtmManager;
     }

     /**
       * Returns singleton iterator containing the document root
       */
     public DTMAxisIterator getIterator() {
         // main source document @ 0
         return _main.getIterator();
     }

     public String getStringValue() {
         return _main.getStringValue();
     }

     public DTMAxisIterator getChildren(final int node) {
         return _adapters[getDTMId(node)].getChildren(node);
     }

     public DTMAxisIterator getTypedChildren(final int type) {
         return new AxisIterator(Axis.CHILD, type);
     }

     public DTMAxisIterator getAxisIterator(final int axis) {
         return new AxisIterator(axis, NO_TYPE);
     }

     public DTMAxisIterator getTypedAxisIterator(final int axis, final int type)
     {
         return new AxisIterator(axis, type);
     }

     public DTMAxisIterator getNthDescendant(int node, int n,
                                             boolean includeself)
     {
         return _adapters[getDTMId(node)].getNthDescendant(node, n, includeself);
     }

     public DTMAxisIterator getNodeValueIterator(DTMAxisIterator iterator,
                                                 int type, String value,
                                                 boolean op)
     {
         return(new NodeValueIterator(iterator, type, value, op));
     }

     public DTMAxisIterator getNamespaceAxisIterator(final int axis,
                                                     final int ns)
     {
         DTMAxisIterator iterator = _main.getNamespaceAxisIterator(axis, ns);
         return(iterator);
     }

     public DTMAxisIterator orderNodes(DTMAxisIterator source, int node) {
         return _adapters[getDTMId(node)].orderNodes(source, node);
     }

     public int getExpandedTypeID(final int node) {
         if (node != DTM.NULL) {
             return _adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].getExpandedTypeID(node);
         }
         else {
             return DTM.NULL;
         }
     }

     public int getNamespaceType(final int node) {
         return _adapters[getDTMId(node)].getNamespaceType(node);
     }

     public int getNSType(int node)
    {
         return _adapters[getDTMId(node)].getNSType(node);
    }

     public int getParent(final int node) {
         if (node == DTM.NULL) {
             return DTM.NULL;
         }
         return _adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].getParent(node);
     }

     public int getAttributeNode(final int type, final int el) {
         if (el == DTM.NULL) {
             return DTM.NULL;
         }
         return _adapters[el >>> DTMManager.IDENT_DTM_NODE_BITS].getAttributeNode(type, el);
     }

     public String getNodeName(final int node) {
         if (node == DTM.NULL) {
             return "";
         }
         return _adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].getNodeName(node);
     }

     public String getNodeNameX(final int node) {
         if (node == DTM.NULL) {
             return "";
         }
         return _adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].getNodeNameX(node);
     }

     public String getNamespaceName(final int node) {
         if (node == DTM.NULL) {
             return "";
         }
         return _adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].getNamespaceName(node);
     }

     public String getStringValueX(final int node) {
         if (node == DTM.NULL) {
             return "";
         }
         return _adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].getStringValueX(node);
     }

     public void copy(final int node, SerializationHandler handler)
         throws TransletException
     {
         if (node != DTM.NULL) {
             _adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].copy(node, handler);
         }
     }

     public void copy(DTMAxisIterator nodes, SerializationHandler handler)
             throws TransletException
     {
         int node;
         while ((node = nodes.next()) != DTM.NULL) {
             _adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].copy(node, handler);
         }
     }


     public String shallowCopy(final int node, SerializationHandler handler)
             throws TransletException
     {
         if (node == DTM.NULL) {
             return "";
         }
         return _adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].shallowCopy(node, handler);
     }

     public boolean lessThan(final int node1, final int node2) {
         if (node1 == DTM.NULL) {
             return true;
         }
         if (node2 == DTM.NULL) {
             return false;
         }
         final int dom1 = getDTMId(node1);
         final int dom2 = getDTMId(node2);
         return dom1 == dom2 ? _adapters[dom1].lessThan(node1, node2)
                             : dom1 < dom2;
     }

     public void characters(final int textNode, SerializationHandler handler)
                  throws TransletException
     {
         if (textNode != DTM.NULL) {
             _adapters[textNode >>> DTMManager.IDENT_DTM_NODE_BITS].characters(textNode, handler);
         }
     }

     public void setFilter(StripFilter filter) {
         for (int dom=0; dom<_free; dom++) {
             if (_adapters[dom] != null) {
                 _adapters[dom].setFilter(filter);
             }
         }
     }

     public Node makeNode(int index) {
         if (index == DTM.NULL) {
             return null;
         }
         return _adapters[getDTMId(index)].makeNode(index);
     }

     public Node makeNode(DTMAxisIterator iter) {
         // TODO: gather nodes from all DOMs ?
         return _main.makeNode(iter);
     }

     public NodeList makeNodeList(int index) {
         if (index == DTM.NULL) {
             return null;
         }
         return _adapters[getDTMId(index)].makeNodeList(index);
     }

     public NodeList makeNodeList(DTMAxisIterator iter) {
         int index = iter.next();
         if (index == DTM.NULL) {
             return new DTMAxisIterNodeList(null, null);
         }
         iter.reset();
         return _adapters[getDTMId(index)].makeNodeList(iter);
     }

     public String getLanguage(int node) {
         return _adapters[getDTMId(node)].getLanguage(node);
     }

     public int getSize() {
         int size = 0;
         for (int i=0; i<_size; i++) {
             size += _adapters[i].getSize();
         }
         return(size);
     }

     public String getDocumentURI(int node) {
         if (node == DTM.NULL) {
             node = DOM.NULL;
         }
         return _adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].getDocumentURI(0);
     }

     public boolean isElement(final int node) {
         if (node == DTM.NULL) {
             return false;
         }
         return(_adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].isElement(node));
     }

     public boolean isAttribute(final int node) {
         if (node == DTM.NULL) {
             return false;
         }
         return(_adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].isAttribute(node));
     }

     public int getDTMId(int nodeHandle)
     {
         if (nodeHandle == DTM.NULL)
             return 0;

         int id = nodeHandle >>> DTMManager.IDENT_DTM_NODE_BITS;
         while (id >= 2 && _adapters[id] == _adapters[id-1]) {
             id--;
         }
         return id;
     }

     public DOM getDTM(int nodeHandle) {
         return _adapters[getDTMId(nodeHandle)];
     }

     public int getNodeIdent(int nodeHandle)
     {
         return _adapters[nodeHandle >>> DTMManager.IDENT_DTM_NODE_BITS].getNodeIdent(nodeHandle);
     }

     public int getNodeHandle(int nodeId)
     {
         return _main.getNodeHandle(nodeId);
     }

     public DOM getResultTreeFrag(int initSize, int rtfType)
     {
         return _main.getResultTreeFrag(initSize, rtfType);
     }

     public DOM getResultTreeFrag(int initSize, int rtfType, boolean addToManager)
     {
         return _main.getResultTreeFrag(initSize, rtfType, addToManager);
     }

     public DOM getMain()
     {
         return _main;
     }

     /**
      * Returns a DOMBuilder class wrapped in a SAX adapter.
      */
     public SerializationHandler getOutputDomBuilder()
     {
         return _main.getOutputDomBuilder();
     }

     public String lookupNamespace(int node, String prefix)
         throws TransletException
     {
         return _main.lookupNamespace(node, prefix);
     }

     // %HZ% Does this method make any sense here???
     public String getUnparsedEntityURI(String entity) {
         return _main.getUnparsedEntityURI(entity);
     }

     // %HZ% Does this method make any sense here???
     public Map<String, Integer> getElementsWithIDs() {
         return _main.getElementsWithIDs();
     }

     public void release() {
         _main.release();
     }

     private boolean isMatchingAdapterEntry(DOM entry, DOMAdapter adapter) {
         DOM dom = adapter.getDOMImpl();

         return (entry == adapter) || (
             /*
              * Method addDOMAdapter overwrites for AdaptiveResultTreeImpl
              * objects the usual entry with an adapter to the nested
              * DOM, so we must check this here. See last 'if' statement
              * of addDOMAdapter.
              */
             (dom instanceof AdaptiveResultTreeImpl) &&
             (entry instanceof DOMAdapter) &&
             (((AdaptiveResultTreeImpl)dom).getNestedDOM() == ((DOMAdapter)entry).getDOMImpl())
         );
     }

     public void removeDOMAdapter(DOMAdapter adapter) {
         _documents.remove(adapter.getDocumentURI(0));
         DOM dom = adapter.getDOMImpl();

         if (dom instanceof DTMDefaultBase) {
             SuballocatedIntVector ids = ((DTMDefaultBase) dom).getDTMIDs();
             int idsSize = ids.size();
             for (int i = 0; i < idsSize; i++) {
                 _adapters[ids.elementAt(i) >>> DTMManager.IDENT_DTM_NODE_BITS] = null;
             }
         } else {
             int id = dom.getDocument() >>> DTMManager.IDENT_DTM_NODE_BITS;
             if ((id > 0) && (id < _adapters.length) && isMatchingAdapterEntry(_adapters[id], adapter)) {
                 _adapters[id] = null;
             } else {
                 boolean found = false;
                 for (int i = 0; i < _adapters.length; i++) {
                     if (isMatchingAdapterEntry(_adapters[id], adapter)) {
                         _adapters[i] = null;
                         found = true;
                         break;
                     }
                 }
             }
         }
     }
 }
	/*
	* Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
	*/
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.sun.org.apache.xalan.internal.xsltc.dom;

	import com.sun.org.apache.xalan.internal.xsltc.DOM;
	import com.sun.org.apache.xalan.internal.xsltc.StripFilter;
	import com.sun.org.apache.xalan.internal.xsltc.TransletException;
	import com.sun.org.apache.xalan.internal.xsltc.runtime.BasisLibrary;
	import com.sun.org.apache.xml.internal.dtm.Axis;
	import com.sun.org.apache.xml.internal.dtm.DTM;
	import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
	import com.sun.org.apache.xml.internal.dtm.DTMManager;
	import com.sun.org.apache.xml.internal.dtm.ref.DTMAxisIteratorBase;
	import com.sun.org.apache.xml.internal.dtm.ref.DTMAxisIterNodeList;
	import com.sun.org.apache.xml.internal.dtm.ref.DTMDefaultBase;
	import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
	import com.sun.org.apache.xml.internal.utils.SuballocatedIntVector;
	import java.util.HashMap;
	import java.util.Map;
	import org.w3c.dom.Node;
	import org.w3c.dom.NodeList;

	/**
	* @author Jacek Ambroziak
	* @author Morten Jorgensen
	* @author Erwin Bolwidt <ejb@klomp.org>
	*/
	public final class MultiDOM implements DOM {

	private static final int NO_TYPE = DOM.FIRST_TYPE - 2;
	private static final int INITIAL_SIZE = 4;

	private DOM[] _adapters;
	private DOMAdapter _main;
	private DTMManager _dtmManager;
	private int _free;
	private int _size;

	private Map<String, Integer> _documents = new HashMap<>();

	private final class AxisIterator extends DTMAxisIteratorBase {
	// constitutive data
	private final int _axis;
	private final int _type;
	// implementation mechanism
	private DTMAxisIterator _source;
	private int _dtmId = -1;

	public AxisIterator(final int axis, final int type) {
	_axis = axis;
	_type = type;
	}

	public int next() {
	if (_source == null) {
	return(END);
	}
	return _source.next();
	}


	public void setRestartable(boolean flag) {
	if (_source != null) {
	_source.setRestartable(flag);
	}
	}

	public DTMAxisIterator setStartNode(final int node) {
	if (node == DTM.NULL) {
	return this;
	}

	int dom = node >>> DTMManager.IDENT_DTM_NODE_BITS;

	// Get a new source first time and when mask changes
	if (_source == null \|\| _dtmId != dom) {
	if (_type == NO_TYPE) {
	_source = _adapters[dom].getAxisIterator(_axis);
	} else if (_axis == Axis.CHILD) {
	_source = _adapters[dom].getTypedChildren(_type);
	} else {
	_source = _adapters[dom].getTypedAxisIterator(_axis, _type);
	}
	}

	_dtmId = dom;
	_source.setStartNode(node);
	return this;
	}

	public DTMAxisIterator reset() {
	if (_source != null) {
	_source.reset();
	}
	return this;
	}

	public int getLast() {
	if (_source != null) {
	return _source.getLast();
	}
	else {
	return END;
	}
	}

	public int getPosition() {
	if (_source != null) {
	return _source.getPosition();
	}
	else {
	return END;
	}
	}

	public boolean isReverse() {
	return Axis.isReverse(_axis);
	}

	public void setMark() {
	if (_source != null) {
	_source.setMark();
	}
	}

	public void gotoMark() {
	if (_source != null) {
	_source.gotoMark();
	}
	}

	public DTMAxisIterator cloneIterator() {
	final AxisIterator clone = new AxisIterator(_axis, _type);
	if (_source != null) {
	clone._source = _source.cloneIterator();
	}
	clone._dtmId = _dtmId;
	return clone;
	}
	} // end of AxisIterator


	/**************************************************************
	* This is a specialised iterator for predicates comparing node or
	* attribute values to variable or parameter values.
	*/
	private final class NodeValueIterator extends DTMAxisIteratorBase {

	private DTMAxisIterator _source;
	private String _value;
	private boolean _op;
	private final boolean _isReverse;
	private int _returnType = RETURN_PARENT;

	public NodeValueIterator(DTMAxisIterator source, int returnType,
	String value, boolean op) {
	_source = source;
	_returnType = returnType;
	_value = value;
	_op = op;
	_isReverse = source.isReverse();
	}

	public boolean isReverse() {
	return _isReverse;
	}

	public DTMAxisIterator cloneIterator() {
	try {
	NodeValueIterator clone = (NodeValueIterator)super.clone();
	clone._source = _source.cloneIterator();
	clone.setRestartable(false);
	return clone.reset();
	}
	catch (CloneNotSupportedException e) {
	BasisLibrary.runTimeError(BasisLibrary.ITERATOR_CLONE_ERR,
	e.toString());
	return null;
	}
	}


	public void setRestartable(boolean isRestartable) {
	_isRestartable = isRestartable;
	_source.setRestartable(isRestartable);
	}

	public DTMAxisIterator reset() {
	_source.reset();
	return resetPosition();
	}

	public int next() {

	int node;
	while ((node = _source.next()) != END) {
	String val = getStringValueX(node);
	if (_value.equals(val) == _op) {
	if (_returnType == RETURN_CURRENT)
	return returnNode(node);
	else
	return returnNode(getParent(node));
	}
	}
	return END;
	}

	public DTMAxisIterator setStartNode(int node) {
	if (_isRestartable) {
	_source.setStartNode(_startNode = node);
	return resetPosition();
	}
	return this;
	}

	public void setMark() {
	_source.setMark();
	}

	public void gotoMark() {
	_source.gotoMark();
	}
	}

	public MultiDOM(DOM main) {
	_size = INITIAL_SIZE;
	_free = 1;
	_adapters = new DOM[INITIAL_SIZE];
	DOMAdapter adapter = (DOMAdapter)main;
	_adapters[0] = adapter;
	_main = adapter;
	DOM dom = adapter.getDOMImpl();
	if (dom instanceof DTMDefaultBase) {
	_dtmManager = ((DTMDefaultBase)dom).getManager();
	}

	// %HZ% %REVISIT% Is this the right thing to do here? In the old
	// %HZ% %REVISIT% version, the main document did not get added through
	// %HZ% %REVISIT% a call to addDOMAdapter, which meant it couldn't be
	// %HZ% %REVISIT% found by a call to getDocumentMask. The problem is
	// %HZ% %REVISIT% TransformerHandler is typically constructed with a
	// %HZ% %REVISIT% system ID equal to the stylesheet's URI; with SAX
	// %HZ% %REVISIT% input, it ends up giving that URI to the document.
	// %HZ% %REVISIT% Then, any references to document('') are resolved
	// %HZ% %REVISIT% using the stylesheet's URI.
	// %HZ% %REVISIT% MultiDOM.getDocumentMask is called to verify that
	// %HZ% %REVISIT% a document associated with that URI has not been
	// %HZ% %REVISIT% encountered, and that method ends up returning the
	// %HZ% %REVISIT% mask of the main document, when what we really what
	// %HZ% %REVISIT% is to read the stylesheet itself!
	addDOMAdapter(adapter, false);
	}

	public int nextMask() {
	return _free;
	}

	public void setupMapping(String[] names, String[] uris, int[] types, String[] namespaces) {
	// This method only has a function in DOM adapters
	}

	public int addDOMAdapter(DOMAdapter adapter) {
	return addDOMAdapter(adapter, true);
	}

	private int addDOMAdapter(DOMAdapter adapter, boolean indexByURI) {
	// Add the DOM adapter to the array of DOMs
	DOM dom = adapter.getDOMImpl();

	int domNo = 1;
	int dtmSize = 1;
	SuballocatedIntVector dtmIds = null;
	if (dom instanceof DTMDefaultBase) {
	DTMDefaultBase dtmdb = (DTMDefaultBase)dom;
	dtmIds = dtmdb.getDTMIDs();
	dtmSize = dtmIds.size();
	domNo = dtmIds.elementAt(dtmSize-1) >>> DTMManager.IDENT_DTM_NODE_BITS;
	}
	else if (dom instanceof SimpleResultTreeImpl) {
	SimpleResultTreeImpl simpleRTF = (SimpleResultTreeImpl)dom;
	domNo = simpleRTF.getDocument() >>> DTMManager.IDENT_DTM_NODE_BITS;
	}

	if (domNo >= _size) {
	int oldSize = _size;
	do {
	_size *= 2;
	} while (_size <= domNo);

	final DOMAdapter[] newArray = new DOMAdapter[_size];
	System.arraycopy(_adapters, 0, newArray, 0, oldSize);
	_adapters = newArray;
	}

	_free = domNo + 1;

	if (dtmSize == 1) {
	_adapters[domNo] = adapter;
	}
	else if (dtmIds != null) {
	int domPos = 0;
	for (int i = dtmSize - 1; i >= 0; i--) {
	domPos = dtmIds.elementAt(i) >>> DTMManager.IDENT_DTM_NODE_BITS;
	_adapters[domPos] = adapter;
	}
	domNo = domPos;
	}

	// Store reference to document (URI) in the Map
	if (indexByURI) {
	String uri = adapter.getDocumentURI(0);
	_documents.put(uri, domNo);
	}

	// If the dom is an AdaptiveResultTreeImpl, we need to create a
	// DOMAdapter around its nested dom object (if it is non-null) and
	// add the DOMAdapter to the list.
	if (dom instanceof AdaptiveResultTreeImpl) {
	AdaptiveResultTreeImpl adaptiveRTF = (AdaptiveResultTreeImpl)dom;
	DOM nestedDom = adaptiveRTF.getNestedDOM();
	if (nestedDom != null) {
	DOMAdapter newAdapter = new DOMAdapter(nestedDom,
	adapter.getNamesArray(),
	adapter.getUrisArray(),
	adapter.getTypesArray(),
	adapter.getNamespaceArray());
	addDOMAdapter(newAdapter);
	}
	}

	return domNo;
	}

	public int getDocumentMask(String uri) {
	Integer domIdx = _documents.get(uri);
	if (domIdx == null) {
	return(-1);
	} else {
	return domIdx.intValue();
	}
	}

	public DOM getDOMAdapter(String uri) {
	Integer domIdx = _documents.get(uri);
	if (domIdx == null) {
	return(null);
	} else {
	return(_adapters[domIdx.intValue()]);
	}
	}

	public int getDocument()
	{
	return _main.getDocument();
	}

	public DTMManager getDTMManager() {
	return _dtmManager;
	}

	/**
	* Returns singleton iterator containing the document root
	*/
	public DTMAxisIterator getIterator() {
	// main source document @ 0
	return _main.getIterator();
	}

	public String getStringValue() {
	return _main.getStringValue();
	}

	public DTMAxisIterator getChildren(final int node) {
	return _adapters[getDTMId(node)].getChildren(node);
	}

	public DTMAxisIterator getTypedChildren(final int type) {
	return new AxisIterator(Axis.CHILD, type);
	}

	public DTMAxisIterator getAxisIterator(final int axis) {
	return new AxisIterator(axis, NO_TYPE);
	}

	public DTMAxisIterator getTypedAxisIterator(final int axis, final int type)
	{
	return new AxisIterator(axis, type);
	}

	public DTMAxisIterator getNthDescendant(int node, int n,
	boolean includeself)
	{
	return _adapters[getDTMId(node)].getNthDescendant(node, n, includeself);
	}

	public DTMAxisIterator getNodeValueIterator(DTMAxisIterator iterator,
	int type, String value,
	boolean op)
	{
	return(new NodeValueIterator(iterator, type, value, op));
	}

	public DTMAxisIterator getNamespaceAxisIterator(final int axis,
	final int ns)
	{
	DTMAxisIterator iterator = _main.getNamespaceAxisIterator(axis, ns);
	return(iterator);
	}

	public DTMAxisIterator orderNodes(DTMAxisIterator source, int node) {
	return _adapters[getDTMId(node)].orderNodes(source, node);
	}

	public int getExpandedTypeID(final int node) {
	if (node != DTM.NULL) {
	return _adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].getExpandedTypeID(node);
	}
	else {
	return DTM.NULL;
	}
	}

	public int getNamespaceType(final int node) {
	return _adapters[getDTMId(node)].getNamespaceType(node);
	}

	public int getNSType(int node)
	{
	return _adapters[getDTMId(node)].getNSType(node);
	}

	public int getParent(final int node) {
	if (node == DTM.NULL) {
	return DTM.NULL;
	}
	return _adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].getParent(node);
	}

	public int getAttributeNode(final int type, final int el) {
	if (el == DTM.NULL) {
	return DTM.NULL;
	}
	return _adapters[el >>> DTMManager.IDENT_DTM_NODE_BITS].getAttributeNode(type, el);
	}

	public String getNodeName(final int node) {
	if (node == DTM.NULL) {
	return "";
	}
	return _adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].getNodeName(node);
	}

	public String getNodeNameX(final int node) {
	if (node == DTM.NULL) {
	return "";
	}
	return _adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].getNodeNameX(node);
	}

	public String getNamespaceName(final int node) {
	if (node == DTM.NULL) {
	return "";
	}
	return _adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].getNamespaceName(node);
	}

	public String getStringValueX(final int node) {
	if (node == DTM.NULL) {
	return "";
	}
	return _adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].getStringValueX(node);
	}

	public void copy(final int node, SerializationHandler handler)
	throws TransletException
	{
	if (node != DTM.NULL) {
	_adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].copy(node, handler);
	}
	}

	public void copy(DTMAxisIterator nodes, SerializationHandler handler)
	throws TransletException
	{
	int node;
	while ((node = nodes.next()) != DTM.NULL) {
	_adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].copy(node, handler);
	}
	}


	public String shallowCopy(final int node, SerializationHandler handler)
	throws TransletException
	{
	if (node == DTM.NULL) {
	return "";
	}
	return _adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].shallowCopy(node, handler);
	}

	public boolean lessThan(final int node1, final int node2) {
	if (node1 == DTM.NULL) {
	return true;
	}
	if (node2 == DTM.NULL) {
	return false;
	}
	final int dom1 = getDTMId(node1);
	final int dom2 = getDTMId(node2);
	return dom1 == dom2 ? _adapters[dom1].lessThan(node1, node2)
	: dom1 < dom2;
	}

	public void characters(final int textNode, SerializationHandler handler)
	throws TransletException
	{
	if (textNode != DTM.NULL) {
	_adapters[textNode >>> DTMManager.IDENT_DTM_NODE_BITS].characters(textNode, handler);
	}
	}

	public void setFilter(StripFilter filter) {
	for (int dom=0; dom<_free; dom++) {
	if (_adapters[dom] != null) {
	_adapters[dom].setFilter(filter);
	}
	}
	}

	public Node makeNode(int index) {
	if (index == DTM.NULL) {
	return null;
	}
	return _adapters[getDTMId(index)].makeNode(index);
	}

	public Node makeNode(DTMAxisIterator iter) {
	// TODO: gather nodes from all DOMs ?
	return _main.makeNode(iter);
	}

	public NodeList makeNodeList(int index) {
	if (index == DTM.NULL) {
	return null;
	}
	return _adapters[getDTMId(index)].makeNodeList(index);
	}

	public NodeList makeNodeList(DTMAxisIterator iter) {
	int index = iter.next();
	if (index == DTM.NULL) {
	return new DTMAxisIterNodeList(null, null);
	}
	iter.reset();
	return _adapters[getDTMId(index)].makeNodeList(iter);
	}

	public String getLanguage(int node) {
	return _adapters[getDTMId(node)].getLanguage(node);
	}

	public int getSize() {
	int size = 0;
	for (int i=0; i<_size; i++) {
	size += _adapters[i].getSize();
	}
	return(size);
	}

	public String getDocumentURI(int node) {
	if (node == DTM.NULL) {
	node = DOM.NULL;
	}
	return _adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].getDocumentURI(0);
	}

	public boolean isElement(final int node) {
	if (node == DTM.NULL) {
	return false;
	}
	return(_adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].isElement(node));
	}

	public boolean isAttribute(final int node) {
	if (node == DTM.NULL) {
	return false;
	}
	return(_adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].isAttribute(node));
	}

	public int getDTMId(int nodeHandle)
	{
	if (nodeHandle == DTM.NULL)
	return 0;

	int id = nodeHandle >>> DTMManager.IDENT_DTM_NODE_BITS;
	while (id >= 2 && _adapters[id] == _adapters[id-1]) {
	id--;
	}
	return id;
	}

	public DOM getDTM(int nodeHandle) {
	return _adapters[getDTMId(nodeHandle)];
	}

	public int getNodeIdent(int nodeHandle)
	{
	return _adapters[nodeHandle >>> DTMManager.IDENT_DTM_NODE_BITS].getNodeIdent(nodeHandle);
	}

	public int getNodeHandle(int nodeId)
	{
	return _main.getNodeHandle(nodeId);
	}

	public DOM getResultTreeFrag(int initSize, int rtfType)
	{
	return _main.getResultTreeFrag(initSize, rtfType);
	}

	public DOM getResultTreeFrag(int initSize, int rtfType, boolean addToManager)
	{
	return _main.getResultTreeFrag(initSize, rtfType, addToManager);
	}

	public DOM getMain()
	{
	return _main;
	}

	/**
	* Returns a DOMBuilder class wrapped in a SAX adapter.
	*/
	public SerializationHandler getOutputDomBuilder()
	{
	return _main.getOutputDomBuilder();
	}

	public String lookupNamespace(int node, String prefix)
	throws TransletException
	{
	return _main.lookupNamespace(node, prefix);
	}

	// %HZ% Does this method make any sense here???
	public String getUnparsedEntityURI(String entity) {
	return _main.getUnparsedEntityURI(entity);
	}

	// %HZ% Does this method make any sense here???
	public Map<String, Integer> getElementsWithIDs() {
	return _main.getElementsWithIDs();
	}

	public void release() {
	_main.release();
	}

	private boolean isMatchingAdapterEntry(DOM entry, DOMAdapter adapter) {
	DOM dom = adapter.getDOMImpl();

	return (entry == adapter) \|\| (
	/*
	* Method addDOMAdapter overwrites for AdaptiveResultTreeImpl
	* objects the usual entry with an adapter to the nested
	* DOM, so we must check this here. See last 'if' statement
	* of addDOMAdapter.
	*/
	(dom instanceof AdaptiveResultTreeImpl) &&
	(entry instanceof DOMAdapter) &&
	(((AdaptiveResultTreeImpl)dom).getNestedDOM() == ((DOMAdapter)entry).getDOMImpl())
	);
	}

	public void removeDOMAdapter(DOMAdapter adapter) {
	_documents.remove(adapter.getDocumentURI(0));
	DOM dom = adapter.getDOMImpl();

	if (dom instanceof DTMDefaultBase) {
	SuballocatedIntVector ids = ((DTMDefaultBase) dom).getDTMIDs();
	int idsSize = ids.size();
	for (int i = 0; i < idsSize; i++) {
	_adapters[ids.elementAt(i) >>> DTMManager.IDENT_DTM_NODE_BITS] = null;
	}
	} else {
	int id = dom.getDocument() >>> DTMManager.IDENT_DTM_NODE_BITS;
	if ((id > 0) && (id < _adapters.length) && isMatchingAdapterEntry(_adapters[id], adapter)) {
	_adapters[id] = null;
	} else {
	boolean found = false;
	for (int i = 0; i < _adapters.length; i++) {
	if (isMatchingAdapterEntry(_adapters[id], adapter)) {
	_adapters[i] = null;
	found = true;
	break;
	}
	}
	}
	}
	}
	}