## net.sf.saxon.option.dom4j
Class DOM4JObjectModel

    java.lang.Object
      net.sf.saxon.om.TreeModel
          net.sf.saxon.option.dom4j.DOM4JObjectModel

All Implemented Interfaces:
  Serializable, ExternalObjectModel

    public class DOM4JObjectModel

extends TreeModel
implements ExternalObjectModel, Serializable

This class is the DOM4J implementation of Saxon's ExternalObjectModel interface; it supports the wrapping of DOM4J documents as instances of the Saxon NodeInfo interface.

See Also:
  Serialized Form

Field Summary

Fields inherited from class net.sf.saxon.om.TreeModel
`LINKED_TREE, TINY_TREE, TINY_TREE_CONDENSED`

Constructor Summary
`DOM4JObjectModel()`

Method Summary
`Receiver` `getDocumentBuilder(Result result)` 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.
`String` `getIdentifyingURI()` Get the URI of the external object model as used in the JAXP factory interfaces for obtaining an XPath implementation
`static DOM4JObjectModel` `getInstance()` Get a singular instance of this class
`JPConverter` `getJPConverter(Class sourceClass)` Get a converter from values in the external object model to XPath values.
`PJConverter` `getNodeListCreator(Object node)` Get a converter that converts a sequence of XPath nodes to this model's representation of a node list.
`PJConverter` `getPJConverter(Class targetClass)` Get a converter from XPath values to values in the external object model
`boolean` `isRecognizedNode(Object object)` Test whether this object model recognizes a given node as one of its own
`Builder` `makeBuilder(PipelineConfiguration pipe)` Make a Builder to construct an instance of this tree model from a stream of events
`boolean` `sendSource(Source source, Receiver receiver)` 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.
`NodeInfo` `unravel(Source source, Configuration config)` Wrap or unwrap a node using this object model to return the corresponding Saxon node.
`DocumentInfo` `wrapDocument(Object node, String baseURI, Configuration config)` Wrap a document node in the external object model in a document wrapper that implements the Saxon DocumentInfo interface
`NodeInfo` `wrapNode(DocumentInfo document, Object node)` Wrap a node within the external object model in a node wrapper that implements the Saxon VirtualNode interface (which is an extension of NodeInfo)

Methods inherited from class net.sf.saxon.om.TreeModel
`getSymbolicValue, getTreeModel, isMutable`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### DOM4JObjectModel

    public DOM4JObjectModel()

Method Detail

### getInstance

    public static DOM4JObjectModel getInstance()

  Get a singular instance of this class

  Returns:
    a singular instance of this class

### getIdentifyingURI

    public String getIdentifyingURI()

  Get the URI of the external object model as used in the JAXP factory interfaces for obtaining an XPath implementation

  Specified by:
    `getIdentifyingURI` in interface `ExternalObjectModel`
  Returns:
    the URI used to identify this object model in the JAXP XPath factory mechanism.

### makeBuilder

    public Builder makeBuilder(PipelineConfiguration pipe)

  Description copied from class: `TreeModel`
  Make a Builder to construct an instance of this tree model from a stream of events

  Specified by:
    `makeBuilder` in class `TreeModel`
  Returns:
    a newly created Builder @param pipe

### getPJConverter

    public PJConverter getPJConverter(Class targetClass)

  Description copied from interface: `ExternalObjectModel`
  Get a converter from XPath values to values in the external object model

  Specified by:
    `getPJConverter` in interface `ExternalObjectModel`
  Parameters:
    `targetClass` - the required class of the result of the conversion. If this class represents a node or list of nodes in the external object model, the method should return a converter that takes a native node or sequence of nodes as input and returns a node or sequence of nodes in the external object model representation. Otherwise, it should return null.
  Returns:
    a converter, if the targetClass is recognized as belonging to this object model; otherwise null

### getJPConverter

    public JPConverter getJPConverter(Class sourceClass)

  Description copied from interface: `ExternalObjectModel`
  Get a converter from values in the external object model to XPath values.

  Specified by:
    `getJPConverter` in interface `ExternalObjectModel`
  Parameters:
    `sourceClass` - the class (static or dynamic) of values to be converted
  Returns:
    a converter, if the sourceClass is recognized as belonging to this object model; otherwise null

### getNodeListCreator

    public PJConverter getNodeListCreator(Object node)

  Get a converter that converts a sequence of XPath nodes to this model's representation of a node list.

  Specified by:
    `getNodeListCreator` in interface `ExternalObjectModel`
  Parameters:
    `node` - an example of the kind of node used in this model
  Returns:
    if the model does not recognize this node as one of its own, return null. Otherwise return a PJConverter that takes a list of XPath nodes (represented as NodeInfo objects) and returns a collection of nodes in this object model

### isRecognizedNode

    public boolean isRecognizedNode(Object object)

  Test whether this object model recognizes a given node as one of its own

### getDocumentBuilder

    public Receiver getDocumentBuilder(Result result)

  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.

  Specified by:
    `getDocumentBuilder` in interface `ExternalObjectModel`
  Parameters:
    `result` - a JAXP result object
  Returns:
    a Receiver that writes to that result, if available; or null otherwise

### sendSource

    public boolean sendSource(Source source,
                              Receiver receiver)
                       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.

  Specified by:
    `sendSource` in interface `ExternalObjectModel`
  Parameters:
    `source` - a JAXP Source object
    `receiver` - the Receiver that is to receive the data from the Source
  Returns:
    true if the data from the Source has been sent to the Receiver, false otherwise
  Throws:
    `XPathException`

### unravel

    public NodeInfo unravel(Source source,
                            Configuration config)

  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

  Specified by:
    `unravel` in interface `ExternalObjectModel`
  Parameters:
    `source` - a JAXP Source object
    `config` - the Saxon configuration
  Returns:
    a NodeInfo corresponding to the Source, if this can be constructed; otherwise null

### wrapDocument

    public DocumentInfo wrapDocument(Object node,
                                     String baseURI,
                                     Configuration config)

  Wrap a document node in the external object model in a document wrapper that implements the Saxon DocumentInfo interface

  Parameters:
    `node` - a node (any node) in the third party document
    `baseURI` - the base URI of the node (supply "" if unknown)
    `config` - the Saxon configuration (which among other things provides access to the NamePool)
  Returns:
    the wrapper, which must implement DocumentInfo

### wrapNode

    public NodeInfo wrapNode(DocumentInfo document,
                             Object node)

  Wrap a node within the external object model in a node wrapper that implements the Saxon VirtualNode interface (which is an extension of NodeInfo)

  Parameters:
    `document` - the document wrapper, as a DocumentInfo object
    `node` - the node to be wrapped. This must be a node within the document wrapped by the DocumentInfo provided in the first argument
  Returns:
    the wrapper for the node, as an instance of VirtualNode

Copyright (c) 2004-2010 Saxonica Limited. All rights reserved.