ExternalObjectModel.java
| Index Score | ||
|---|---|---|
![]() |
![]() |
net.sf.saxon.om |
![]() |
![]() |
Saxon |
View: Reasons, Metrics, Source Code
These are the metrics that contribute to the Enerjy Score for this file, ranked by impact. So the metrics listed at the top influence the score to a greater extent that the metrics listed at the bottom.
package net.sf.saxon.om;
import net.sf.saxon.Configuration;
import net.sf.saxon.event.Receiver;
import net.sf.saxon.event.PipelineConfiguration;
import net.sf.saxon.expr.XPathContext;
import net.sf.saxon.trans.XPathException;
import net.sf.saxon.value.Value;
import net.sf.saxon.value.SequenceExtent;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
/**
* This interface must be implemented by any third-party object model that can
* be wrapped with a wrapper that implements the Saxon Object Model (the NodeInfo interface).
* <p>
* This interface is designed to enable advanced applications to implement and register
* new object model implementations that Saxon can then use without change. Although it is intended
* for external use, it cannot at this stage be considered part of the stable Saxon Public API.
* In particular, it is likely that the interface will grow by the addition of new methods.
*/
public interface ExternalObjectModel {
/**
* Test whether this object model recognizes a given node as one of its own. This method
* will generally be called at run time.
* @param object An object that possibly represents a node
* @return true if the object is a representation of a node in this object model
*/
public boolean isRecognizedNode(Object object);
/**
* Test whether this object model recognizes a given class as representing a
* node in that object model. This method will generally be called at compile time.
* @param nodeClass A class that possibly represents nodes
* @return true if the class is used to represent nodes in this object model
*/
public boolean isRecognizedNodeClass(Class nodeClass);
/**
* Test whether this object model recognizes a given class as representing a
* list of nodes in that object model. This method will generally be called at compile time.
* @param nodeClass A class that possibly represents nodes
* @return true if the class is used to represent nodes in this object model
*/
public boolean isRecognizedNodeListClass(Class nodeClass);
/**
* Test whether this object model recognizes a particular kind of JAXP Result object,
* and if it does, return a Receiver that builds an instance of this data model from
* a sequence of events. If the Result is not recognised, return null.
*/
public Receiver getDocumentBuilder(Result result) throws XPathException;
/**
* Test whether this object model recognizes a particular kind of JAXP Source object,
* and if it does, send the contents of the document to a supplied Receiver, and return true.
* Otherwise, return false.
*/
public boolean sendSource(Source source, Receiver receiver, PipelineConfiguration pipe) throws XPathException;
/**
* Wrap or unwrap a node using this object model to return the corresponding Saxon node. If the supplied
* source does not belong to this object model, return null
*/
public NodeInfo unravel(Source source, Configuration config);
/**
* Convert a Java object to an XPath value. If the supplied object is recognized as a representation
* of a value using this object model, the object model should convert the value to an XPath value
* and return this as the result. If not, it should return null. If the object is recognized but cannot
* be converted, an exception should be thrown
*/
public Value convertObjectToXPathValue(Object object, Configuration config) throws XPathException;
/**
* Convert an XPath value to an object in this object model. If the supplied value can be converted
* to an object in this model, of the specified class, then the conversion should be done and the
* resulting object returned. If the value cannot be converted, the method should return null. Note
* that the supplied class might be a List, in which case the method should inspect the contents of the
* Value to see whether they belong to this object model.
* @throws XPathException if the target class is explicitly associated with this object model, but the
* supplied value cannot be converted to the appropriate class
*/
public Object convertXPathValueToObject(Value value, Class targetClass, XPathContext context) throws XPathException;
/**
* Wrap a document node in the external object model in a document wrapper that implements
* the Saxon DocumentInfo interface
* @param node a node (any node) in the third party document
* @param baseURI the base URI of the node (supply "" if unknown)
* @param config the Saxon configuration (which among other things provides access to the NamePool)
* @return the wrapper, which must implement DocumentInfo
*/
public DocumentInfo wrapDocument(Object node, String baseURI, Configuration config);
/**
* Wrap a node within the external object model in a node wrapper that implements the Saxon
* VirtualNode interface (which is an extension of NodeInfo)
* @param document the document wrapper, as a DocumentInfo object
* @param node the node to be wrapped. This must be a node within the document wrapped by the
* DocumentInfo provided in the first argument
* @return the wrapper for the node, as an instance of VirtualNode
*/
public NodeInfo wrapNode(DocumentInfo document, Object node);
/**
* Convert a sequence of values to a NODELIST, as defined in the JAXP XPath API spec. This method
* is used when the evaluate() request specifies the return type as NODELIST, regardless of the
* actual results of the expression. If the sequence contains things other than nodes, the fallback
* is to return the sequence as a Java List object. The method can return null to invoke fallback
* behaviour.
*/
public Object convertToNodeList(SequenceExtent extent);
}
//
// The contents of this file are subject to the Mozilla Public License Version 1.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.mozilla.org/MPL/
//
// Software distributed under the License is distributed on an "AS IS" basis,
// WITHOUT WARRANTY OF ANY KIND, either express or implied.
// See the License for the specific language governing rights and limitations under the License.
//
// The Original Code is: all this file.
//
// The Initial Developer of the Original Code is Michael H. Kay.
//
// Portions created by (your name) are Copyright (C) (your legal entity). All Rights Reserved.
//
// Contributor(s): Gunther Schadow (changes to allow access to public fields; also wrapping
// of extensions and mapping of null to empty sequence).
//
The table below shows all metrics for ExternalObjectModel.java.




