| /* |
| * The Apache Software License, Version 1.1 |
| * |
| * |
| * Copyright (c) 1999 The Apache Software Foundation. All rights |
| * reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * 3. The end-user documentation included with the redistribution, |
| * if any, must include the following acknowledgment: |
| * "This product includes software developed by the |
| * Apache Software Foundation (http://www.apache.org/)." |
| * Alternately, this acknowledgment may appear in the software itself, |
| * if and wherever such third-party acknowledgments normally appear. |
| * |
| * 4. The names "Xalan" and "Apache Software Foundation" must |
| * not be used to endorse or promote products derived from this |
| * software without prior written permission. For written |
| * permission, please contact apache@apache.org. |
| * |
| * 5. Products derived from this software may not be called "Apache", |
| * nor may "Apache" appear in their name, without prior written |
| * permission of the Apache Software Foundation. |
| * |
| * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR |
| * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF |
| * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT |
| * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| * ==================================================================== |
| * |
| * This software consists of voluntary contributions made by many |
| * individuals on behalf of the Apache Software Foundation and was |
| * originally based on software copyright (c) 1999, Lotus |
| * Development Corporation., http://www.lotus.com. For more |
| * information on the Apache Software Foundation, please see |
| * <http://www.apache.org/>. |
| */ |
| package org.apache.xml.dtm.ref.xni2dtm; |
| |
| import org.apache.xerces.impl.dv.InvalidDatatypeValueException; |
| import org.apache.xerces.impl.dv.ValidatedInfo; |
| import org.apache.xerces.impl.dv.xs.XSSimpleTypeDecl; |
| import org.apache.xerces.impl.validation.ValidationState; |
| import org.apache.xerces.impl.xs.XSTypeDecl; |
| import org.apache.xerces.impl.xs.psvi.XSSimpleTypeDefinition; |
| import org.apache.xerces.impl.xs.psvi.XSTypeDefinition; |
| import org.apache.xerces.xni.NamespaceContext; |
| import org.apache.xerces.xni.psvi.ItemPSVI; |
| import org.apache.xml.dtm.DTMSequence; |
| |
| /** The full XNI ItemPSVI is far too heavy-weight for |
| * our needs. But their XSTypeDecl isn't quite heavy enough; it gives |
| * us the actual member type, but that may be anonymous... so to get |
| * what XPath2 considers the proper typename, we need to examine |
| * additional fields as well. This class is an attempt to compromise by |
| * resolving the typename and storing that alongside the member type. |
| * |
| * A more efficient solution undoubtedly exists. But since XNI's PSVI |
| * APIs are still in flux, and since I'm just trying to get an initial |
| * demo running, this will suffice for now. |
| * %REVIEW% periodically! |
| * */ |
| public class XPath2Type |
| { |
| public XSTypeDefinition m_xniType; |
| public String m_namespace; |
| public String m_localName; |
| |
| /** Constructor for our internal type representation |
| * We will extract the low-level XSTypeDecl for the Member Type, |
| * and determine the proper namespace and localname. Other data |
| * can (hopefully) be GC'd after we're done. This is still NOT |
| * a lightweight beast. |
| * |
| * @param psvi XNI Post-Schema-Validation Infoset annotation. |
| * @param isAttr True iff we're defining type for an attribute. |
| * */ |
| public XPath2Type(ItemPSVI psvi, boolean isAttr) |
| { |
| // First get the member type. |
| m_xniType= (psvi==null) ? null : psvi.getTypeDefinition(); |
| |
| // Now resolve the typename. |
| // There are some quibbles about algorithm; see comments on |
| // the resolve methods. |
| heavyResolveTypeName(psvi,isAttr); |
| } |
| |
| /** Constructor for Xerces workaround |
| * (Xerces isn't reminding us of type at the time it provides |
| * validity, so XNI2DTM is passing that data around via a stack. |
| * This is a kluge and I hope to convince Xerces to fix it.) |
| * |
| * @param psvi XNI Post-Schema-Validation Infoset annotation. |
| * @param isAttr True iff we're defining type for an attribute. |
| * */ |
| public XPath2Type(ItemPSVI psvi, XSSimpleTypeDefinition member, XSTypeDefinition type, boolean isAttr) |
| { |
| // First get the member type. |
| m_xniType= (psvi==null) ? null : type; |
| |
| // Now resolve the typename. |
| // There are some quibbles about algorithm; see comments on |
| // the resolve methods. |
| heavyResolveTypeName(psvi,member,type,isAttr); |
| } |
| |
| /** Internal constructor to support getItemType and |
| * AbstractSchema.lookUpType |
| * @param psvi XNI Post-Schema-Validation Infoset annotation. |
| * @param isAttr True iff we're defining type for an attribute. |
| * */ |
| public XPath2Type(XSTypeDefinition itemType, String namespace, String localName) |
| { |
| m_xniType=itemType; |
| m_namespace=namespace; |
| m_localName=localName; |
| } |
| |
| /** Identity needs to be defined so we can do sparse storage. |
| * %REVIEW% I'm not sure all three fields need to be checked, but... |
| * */ |
| public boolean equals(XPath2Type other) |
| { |
| // Could cache hashCode()'s result and use that to accelerate |
| // doesn't-equal testing at the cost of some storage and |
| // slowing down does-equal tests. Not convinced it's useful here. |
| // %REVIEW% |
| return (m_xniType==other.m_xniType || |
| m_xniType!=null && m_xniType.equals(other.m_xniType)) && |
| // These two won't be null |
| m_localName.equals(other.m_localName) && |
| m_namespace.equals(other.m_namespace); |
| } |
| |
| /** Identity needs to be defined so we can do sparse storage. |
| * %REVIEW% I'm not sure all three fields need to be checked, but... |
| * */ |
| public int hashCode() |
| { |
| // Could cache hashCode(). See discussion in equals(). |
| // %REVIEW% |
| return m_namespace.hashCode()+m_localName.hashCode()+ |
| (m_xniType==null ? 0 : m_xniType.hashCode()); |
| } |
| |
| public String getTargetNamespace() {return m_namespace;} |
| public String getTypeName() {return m_localName;} |
| |
| public boolean derivedFrom(String namespace,String localname) |
| { |
| if(m_xniType instanceof XSTypeDecl) |
| return ((XSTypeDecl)m_xniType).derivedFrom(namespace,localname); |
| else |
| { |
| // Fallback in case no PSVI info was passed in: exact match |
| // (it's got to be the correct xsi:any*Type). |
| return(m_localName.equals(localname) && m_namespace.equals(namespace)); |
| } |
| } |
| |
| /** Broken out into a subroutine so I can use it for debugging purposes. |
| * This logic is adapted from the Xerces SimpleTypeUsage.validateString() example. |
| * |
| * %REVIEW% May be more efficient to fold it back in. |
| * |
| * NOTE: Typed value depends on context information -- for example, a |
| * QName must be interpreted w/r/t a specific Namespace context. It's |
| * the caller's responisibility to pass down that information, since only |
| * the caller knows which context this operation is being performed in. |
| * |
| * %REVIEW% Currently NS context comes down as a SAX accessor. Should we be |
| * able to take a DTM node directly as context? |
| * |
| * @param textValue Text content to be interpreted |
| * @param nsctxt SAX namespace context, which will be proxied as XNI. |
| * @return DTM_XSequence containing one or more Java values, as appropriate |
| * to the Built-In Type we have inherited from -- or null if no such |
| * mapping exists (eg, if actualType was complex) |
| * */ |
| public DTMSequence typedValue(String textvalue, org.xml.sax.helpers.NamespaceSupport nsctxt) |
| { |
| Object value; |
| DTM_XSequence seq=null; |
| |
| if(m_xniType instanceof XSSimpleTypeDefinition) |
| { |
| //create an instance of 'ValidatedInfo' to get back information |
| //(like actual value, normalizedValue etc..)after content is validated. |
| ValidatedInfo validatedInfo = new ValidatedInfo(); // %REVIEW% Can we reuse??? |
| |
| //get proper validation context. This is very important, since |
| // it's where we get data for resolving prefixes (in QNames), |
| // known IDs (for IDREFs and ID conflicts), entities, etc. |
| //Validation context passed is generally different while |
| // validating content and creating simple type (applyFacets) |
| ValidationState validationState = new ValidationState(); |
| if(nsctxt!=null) |
| validationState.setNamespaceSupport(new XPath2NamespaceSupport(nsctxt)); |
| |
| // This may need to be bound to additional data using: |
| //validationState.setSymbolTable(....); |
| //validationState.setFacetChecking(...); |
| //validationState.setExtraChecking(...); |
| |
| // Validate and parse the string |
| try{ |
| ((XSSimpleTypeDecl)m_xniType).validate(textvalue, validationState, validatedInfo); |
| } catch(InvalidDatatypeValueException ex){ |
| // %REVIEW% Won't happen in prototype, where I'm only revalidating |
| // existing data. _WILL_ happen in production, when we start generating |
| // new typed data. Needs to be handled better at that time... |
| System.err.println(ex.getMessage()); |
| ex.printStackTrace(System.err); |
| } |
| |
| //now 'validatedInfo' object contains information |
| |
| // for number types (decimal, double, float, and types derived from them), |
| // Object return is BigDecimal, Double, Float respectively. |
| // Boolean is handled similarly. |
| // Some types (string and derived) just return the string itself. |
| value = validatedInfo.actualValue; |
| |
| //The normalized value of a string type |
| // (Should we check for stings and return this instead?) |
| String normalizedValue = validatedInfo.normalizedValue ; |
| |
| // If the type is a union type, then the member type which |
| // actually validated the string value will be: |
| // XSSimpleType memberType = validatedInfo.memberType ; |
| |
| // %REVIEW% I presume this handles lists by returning arrays...? |
| |
| seq=new DTM_XSequence(value,this); |
| } |
| |
| return seq==null ? DTMSequence.EMPTY : seq; |
| } |
| |
| /** @return individual element type, if this is a list-of; else null. |
| * %REVIEW% -- else self? |
| * */ |
| public XPath2Type getItemType() |
| { |
| if(m_xniType instanceof XSSimpleTypeDefinition) |
| { |
| XSTypeDefinition itemType=((XSSimpleTypeDefinition)m_xniType).getItemType(); |
| if(itemType!=null) |
| return new XPath2Type( |
| itemType, |
| m_xniType.getNamespace(), |
| m_xniType.getName()); |
| } |
| return null; |
| } |
| |
| /** Implementation of the XPath2 type-name resolution algorithm |
| * (data model 3.5). |
| * |
| * Code donated by Sandy Gao, using the new |
| * Heavy-Weight PSVI interfaces. |
| * Fractionated to deal with validity and type info not being |
| * simultaneously available in current Xerces. |
| * |
| * @param psvi the psvi information for the current node |
| * @param attr false for element (fallback is xs:anyType) |
| * true for attribute (fallback is xs:anySimpleType) |
| * */ |
| protected void heavyResolveTypeName(ItemPSVI psvi, XSSimpleTypeDefinition member, XSTypeDefinition type, boolean attr) |
| { |
| /* Not compatable with old light-weight schema APIs |
| */ |
| // check whether the node is valid |
| if (psvi == null || |
| psvi.getValidity() != ItemPSVI.VALIDITY_VALID) { |
| // if the node is not valid, then return xs:anyType |
| m_namespace = "http://www.w3.org/2001/XMLSchema"; |
| m_localName = attr ? "anySimpleType" : "anyType"; |
| return; |
| } |
| |
| // try provided member type definition, and return its name |
| if (member != null) { |
| m_namespace = member.getNamespace(); |
| m_localName = member.getName(); |
| return; |
| } |
| |
| // try provided type definition, and return its name |
| if (type != null) { |
| m_namespace = type.getNamespace(); |
| m_localName = type.getName(); |
| return; |
| } |
| |
| |
| // Member type definitions promised to be available; |
| // can't proceed to check names independently |
| |
| // all failed, return xs:anyType |
| m_namespace = "http://www.w3.org/2001/XMLSchema"; |
| m_localName = attr ? "anySimpleType" : "anyType"; |
| return; |
| // throw new java.lang.UnsupportedOperationException("Xerces Heavyweight PSVI not yet avaialble"); /**/ |
| } |
| |
| /** Implementation of the XPath2 type-name resolution algorithm |
| * (data model 3.5). |
| * |
| * Code donated by Sandy Gao, using the new |
| * Heavy-Weight PSVI interfaces |
| * This one works *ONLY* if type and validity are all known in the same |
| * PSVI, which is not the case in current Xerces. |
| * |
| * @param psvi the psvi information for the current node |
| * @param attr false for element (fallback is xs:anyType) |
| * true for attribute (fallback is xs:anySimpleType) |
| * */ |
| protected void heavyResolveTypeName(ItemPSVI psvi, boolean attr) |
| { |
| heavyResolveTypeName(psvi,psvi.getMemberTypeDefinition(), |
| psvi.getTypeDefinition(), attr); |
| } |
| |
| /** Modification of the XPath2 type-name resolution algorithm |
| * to reflect Sandy Gao's concerns about the official version |
| * not tolerating processors that implement the "lightweight" version |
| * of PSVI. |
| * |
| * Code donated by Sandy Gao, using the new |
| * Heavy-Weight PSVI interfaces |
| * |
| * @param psvi the psvi information for the current node |
| * @param attr false for element (fallback is xs:anyType) |
| * true for attribute (fallback is xs:anySimpleType) |
| * */ |
| protected void proposedHeavyResolveTypeName(ItemPSVI psvi, boolean attr) |
| { |
| /* Not compatable with old light-weight schema APIs |
| */ |
| |
| // NAME OF THIS CONSTANT IS IN FLUX |
| int VALID=ItemPSVI.VALIDITY_VALID; |
| //int VALID=ItemPSVI.VALID_VALIDITY; |
| |
| // check whether the node is valid |
| if (psvi == null || |
| psvi.getValidity() != VALID) { |
| // if the node is not valid, then return xs:anyType |
| m_namespace = "http://www.w3.org/2001/XMLSchema"; |
| m_localName = attr ? "anySimpleType" : "anyType"; |
| return; |
| } |
| |
| // try to get the member type definition, and return its name |
| XSSimpleTypeDefinition member = psvi.getMemberTypeDefinition(); |
| if (member != null && member.getName() != null) { |
| m_namespace = member.getNamespace(); |
| m_localName = member.getName(); |
| return; |
| } |
| |
| // try to get the type definition, and return its name |
| XSTypeDefinition type = psvi.getTypeDefinition(); |
| if (type != null && type.getName() != null) { |
| m_namespace = type.getNamespace(); |
| m_localName = type.getName(); |
| return; |
| } |
| |
| // Member type definitions promised to be available; |
| // can't proceed to check names independently |
| |
| // all failed, return xs:anyType |
| m_namespace = "http://www.w3.org/2001/XMLSchema"; |
| m_localName = attr ? "anySimpleType" : "anyType"; |
| return; |
| // throw new java.lang.UnsupportedOperationException("Xerces Heavyweight PSVI not yet avaialble"); /**/ |
| } |
| |
| /** Attempt to write a simplified version of the type resolution |
| * algorithm (data model 3.5) using only the Light-Weight PSVI |
| * interfaces previously supported in Xerces (which I believe will be |
| * phased out when heavyweight come into play). |
| * |
| * Based on code donated by Sandy Gao. |
| * |
| * @param psvi the psvi information for the current node |
| * @param ret a String array with size 2 |
| * index 0 is used to return the namespace name; |
| * index 1 is used to return the local name. |
| * @param attr false for element (fallback is xs:anyType) |
| * true for attribute (fallback is xs:anySimpleType) |
| * */ |
| protected void lightResolveTypeName(ItemPSVI psvi, boolean attr) |
| { |
| /* Not compatable with new heavy-weight schema APIs |
| // |
| |
| int VALID=ItemPSVI.VALID_VALIDITY; |
| |
| // check whether the node is valid |
| if (psvi == null || |
| psvi.getValidity() != VALID) { |
| // if the node is not valid, then return xs:anyType |
| m_namespace = "http://www.w3.org/2001/XMLSchema"; |
| m_localName = attr ? "anySimpleType" : "anyType"; |
| return; |
| } |
| |
| // Member type definitions promised NOT to be available; |
| // proceed to check names independently |
| |
| // Need the second test, apparently |
| if (!psvi.isMemberTypeAnonymous() && null!=psvi.getMemberTypeName() ) { |
| m_namespace = psvi.getMemberTypeNamespace(); |
| m_localName = psvi.getMemberTypeName(); |
| return; |
| } |
| |
| // Need the second test, apparently |
| if (!psvi.isTypeAnonymous() && null!=psvi.getTypeName()) { |
| m_namespace = psvi.getTypeNamespace(); |
| m_localName = psvi.getTypeName(); |
| return; |
| } |
| |
| // all failed, return xs:anyType |
| m_namespace = "http://www.w3.org/2001/XMLSchema"; |
| m_localName = attr ? "anySimpleType" : "anyType"; |
| return; |
| */ throw new java.lang.UnsupportedOperationException("Xerces Lightweight PSVI phased out"); /**/ |
| } |
| |
| |
| //--------------------------------------------------------------------- |
| /** Bridge from Xalan/SAX namespace context to XNI namespace context |
| */ |
| class XPath2NamespaceSupport |
| extends org.apache.xerces.util.NamespaceSupport |
| { |
| org.xml.sax.helpers.NamespaceSupport saxNamespaceSupport; |
| |
| /** Default constructor, not useful in this wrapper. */ |
| public XPath2NamespaceSupport() { |
| throw new UnsupportedOperationException("Wrong c'tor call"); |
| } // <init>() |
| |
| /** |
| * Constructs a namespace context object and initializes it with |
| * the prefixes declared in the specified context. Not useful in this |
| * wrapper. |
| */ |
| public XPath2NamespaceSupport(org.apache.xerces.xni.NamespaceContext context) { |
| throw new UnsupportedOperationException("Wrong c'tor call"); |
| } // <init>(xni.NamespaceContext) |
| |
| /** |
| * Constructs a namespace context object and initializes it with |
| * a SAX NamespaceSupport object. Use this c'tor. |
| * */ |
| public XPath2NamespaceSupport(org.xml.sax.helpers.NamespaceSupport saxNS) { |
| saxNamespaceSupport=saxNS; |
| } // <init>(sax.helpers.NamespaceSupport) |
| |
| // |
| // Public methods |
| // |
| |
| // context management |
| |
| /** |
| * Reset this Namespace support object for reuse. |
| * |
| * <p>It is necessary to invoke this method before reusing the |
| * Namespace support object for a new session.</p> |
| */ |
| public void reset(org.apache.xerces.util.SymbolTable symbolTable) { |
| // no-op |
| } // reset(SymbolTable) |
| |
| /** |
| * Start a new Namespace context. |
| * <p> |
| * Normally, you should push a new context at the beginning |
| * of each XML element: the new context will automatically inherit |
| * the declarations of its parent context, but it will also keep |
| * track of which declarations were made within this context. |
| * <p> |
| * The Namespace support object always starts with a base context |
| * already in force: in this context, only the "xml" prefix is |
| * declared. |
| * |
| * @see #popContext |
| */ |
| public void pushContext() { |
| // I don't know if this will ever be used during validation... |
| saxNamespaceSupport.pushContext(); |
| } // pushContext() |
| |
| |
| /** |
| * Revert to the previous Namespace context. |
| * <p> |
| * Normally, you should pop the context at the end of each |
| * XML element. After popping the context, all Namespace prefix |
| * mappings that were previously in force are restored. |
| * <p> |
| * You must not attempt to declare additional Namespace |
| * prefixes after popping a context, unless you push another |
| * context first. |
| * |
| * @see #pushContext |
| */ |
| public void popContext() { |
| // I don't know if this will ever be used during validation... |
| saxNamespaceSupport.popContext(); |
| } // popContext() |
| |
| // operations within a context. |
| |
| /** |
| * Declare a Namespace prefix. |
| * <p> |
| * This method declares a prefix in the current Namespace |
| * context; the prefix will remain in force until this context |
| * is popped, unless it is shadowed in a descendant context. |
| * <p> |
| * To declare a default Namespace, use the empty string. The |
| * prefix must not be "xml" or "xmlns". |
| * <p> |
| * Note that you must <em>not</em> declare a prefix after |
| * you've pushed and popped another Namespace. |
| * |
| * @param prefix The prefix to declare, or null for the empty |
| * string. |
| * @param uri The Namespace URI to associate with the prefix. |
| * |
| * @return true if the prefix was legal, false otherwise |
| * |
| * @see #getURI |
| * @see #getDeclaredPrefixAt |
| */ |
| public boolean declarePrefix(String prefix, String uri) { |
| // I don't know if this will ever be used during validation... |
| return saxNamespaceSupport.declarePrefix(prefix,uri); |
| } // declarePrefix(String,String):boolean |
| |
| /** |
| * Look up a prefix and get the currently-mapped Namespace URI. |
| * <p> |
| * This method looks up the prefix in the current context. |
| * Use the empty string ("") for the default Namespace. |
| * |
| * @param prefix The prefix to look up. |
| * |
| * @return The associated Namespace URI, or null if the prefix |
| * is undeclared in this context. |
| * |
| * @see #getDeclaredPrefixAt |
| */ |
| public String getURI(String prefix) { |
| return saxNamespaceSupport.getURI(prefix); |
| } // getURI(String):String |
| |
| |
| |
| /** |
| * Look up a namespace URI and get one of the mapped prefix. |
| * <p> |
| * This method looks up the namespace URI in the current context. |
| * |
| * @param uri The namespace URI to look up. |
| * |
| * @return one of the associated prefixes, or null if the uri |
| * does not map to any prefix. |
| * |
| * @see #getPrefix |
| */ |
| public String getPrefix(String uri) { |
| return saxNamespaceSupport.getPrefix(uri); |
| } // getURI(String):String |
| |
| |
| /** |
| * Return a count of all prefixes currently declared, including |
| * the default prefix if bound. |
| */ |
| public int getDeclaredPrefixCount() { |
| java.util.Enumeration e=saxNamespaceSupport.getDeclaredPrefixes(); |
| int count=0; |
| while(e.hasMoreElements()) |
| { |
| ++count; |
| e.nextElement(); |
| } |
| return count; |
| } // getDeclaredPrefixCount():int |
| |
| /** |
| * Returns the prefix at the specified index in the current context. |
| * %REVIEW% Massively inefficient in this implementation. |
| */ |
| public String getDeclaredPrefixAt(int index) { |
| java.util.Enumeration e=saxNamespaceSupport.getDeclaredPrefixes(); |
| String result=null; |
| for(; index>=0;--index) |
| { |
| if(e.hasMoreElements()) |
| result=(String)e.nextElement(); |
| else |
| return null; |
| } |
| return result; |
| } // getDeclaredPrefixAt(int):String |
| |
| /** |
| * Returns the parent namespace context or null if there is no |
| * parent context. The total depth of the namespace contexts |
| * matches the element depth in the document. |
| * <p> |
| * <strong>Note:</strong> This method <em>may</em> return the same |
| * NamespaceContext object reference. The caller is responsible for |
| * saving the declared prefix mappings before calling this method. |
| */ |
| public NamespaceContext getParentContext() { |
| // I suppose I could construct a new XPath2NamespaceSupport |
| // wrapped around the SAX parent context. I'd rather not |
| // unless I must. |
| throw new UnsupportedOperationException("Not supported; involves further crossing XNI/SAX boundaries"); |
| } // getParentContext():NamespaceContext |
| |
| } // class XPath2NamespaceSupport |
| |
| } // XPath2Type |
| |
