/** * Create an object model builder that reads an XML document from the provided character stream * using a specified object model factory and with a given parser configuration. * * @param omFactory * the object model factory to use * @param configuration * the parser configuration to use * @param in * the character stream representing the XML document * @return the builder */ public static OMXMLParserWrapper createOMBuilder(OMFactory omFactory, StAXParserConfiguration configuration, Reader in) { return omFactory.getMetaFactory().createOMBuilder(omFactory, configuration, new InputSource(in)); }
/** * Create an object model builder that reads an XML document from the provided {@link Source} * using a specified object model factory. When used with a {@link DOMSource} or * {@link SAXSource}, entities are expanded, i.e. the method has the same behavior as * {@link #createOMBuilder(OMFactory, Node, boolean)} and * {@link #createOMBuilder(OMFactory, SAXSource, boolean)} with {@code expandEntityReferences} * set to {@code true}. * * @param omFactory * the object model factory to use * @param source * the source of the XML document * @return the builder */ public static OMXMLParserWrapper createOMBuilder(OMFactory omFactory, Source source) { return omFactory.getMetaFactory().createOMBuilder(omFactory, source); }
/** * Create an object model builder that reads an XML document from the provided DOM tree using a * specified object model factory. * * @param omFactory * the object model factory to use * @param node * the DOM node; must be a {@link Node#DOCUMENT_NODE} or {@link Node#ELEMENT_NODE} * @param expandEntityReferences * Determines how {@link EntityReference} nodes are handled: * <ul> * <li>If the parameter is <code>false</code> then a single {@link OMEntityReference} * will be created for each {@link EntityReference}. The child nodes of * {@link EntityReference} nodes are not taken into account. * <li>If the parameter is <code>true</code> then no {@link OMEntityReference} nodes * are created and the children of {@link EntityReference} nodes are converted and * inserted into the Axiom tree. * </ul> * @return the builder */ public static OMXMLParserWrapper createOMBuilder(OMFactory omFactory, Node node, boolean expandEntityReferences) { return omFactory.getMetaFactory().createOMBuilder(omFactory, node, expandEntityReferences); }
/** * Create an object model builder that reads an XML document from the provided input stream * using a specified object model factory and with a given parser configuration. * * @param omFactory * the object model factory to use * @param configuration * the parser configuration to use * @param in * the input stream representing the XML document * @param encoding * the charset encoding of the XML document or <code>null</code> if the parser should * determine the charset encoding * @return the builder */ public static OMXMLParserWrapper createOMBuilder(OMFactory omFactory, StAXParserConfiguration configuration, InputStream in, String encoding) { InputSource is = new InputSource(in); is.setEncoding(encoding); return omFactory.getMetaFactory().createOMBuilder(omFactory, configuration, is); }
/** * Create an object model builder that reads an XML document from the provided {@link SAXSource} * using a specified object model factory. * * @param omFactory * the object model factory to use * @param source * the source of the XML document * @param expandEntityReferences * Determines how entity references (i.e. {@link LexicalHandler#startEntity(String)} * and {@link LexicalHandler#endEntity(String)} events) are handled: * <ul> * <li>If the parameter is <code>false</code> then a single {@link OMEntityReference} * will be created for each pair of {@link LexicalHandler#startEntity(String)} and * {@link LexicalHandler#endEntity(String)} events. Other events reported between * these two events are not taken into account. * <li>If the parameter is <code>true</code> then no {@link OMEntityReference} nodes * are created and {@link LexicalHandler#startEntity(String)} and * {@link LexicalHandler#endEntity(String)} events are ignored. However, events * between {@link LexicalHandler#startEntity(String)} and * {@link LexicalHandler#endEntity(String)} are processed normally. * </ul> * @return the builder */ public static OMXMLParserWrapper createOMBuilder(OMFactory omFactory, SAXSource source, boolean expandEntityReferences) { return omFactory.getMetaFactory().createOMBuilder(omFactory, source, expandEntityReferences); }
/** * Create an object model builder that reads a plain XML document from the provided character * stream with a given parser configuration. * * @param configuration * the parser configuration to use * @param in * the character stream representing the XML document * @return the builder */ public static OMXMLParserWrapper createOMBuilder(StAXParserConfiguration configuration, Reader in) { OMMetaFactory metaFactory = OMAbstractFactory.getMetaFactory(); return metaFactory.createOMBuilder(metaFactory.getOMFactory(), configuration, new InputSource(in)); }
/** * Create an object model builder that reads a plain XML document from the provided input stream * with a given parser configuration. * * @param configuration * the parser configuration to use * @param in * the input stream representing the XML document * @param encoding * the charset encoding of the XML document or <code>null</code> if the parser should * determine the charset encoding * @return the builder */ public static OMXMLParserWrapper createOMBuilder(StAXParserConfiguration configuration, InputStream in, String encoding) { OMMetaFactory metaFactory = OMAbstractFactory.getMetaFactory(); InputSource is = new InputSource(in); is.setEncoding(encoding); return metaFactory.createOMBuilder(metaFactory.getOMFactory(), configuration, is); }
/** * Create an object model builder that reads a plain XML document from the provided * {@link Source}. When used with a {@link DOMSource} or {@link SAXSource}, entities are * expanded, i.e. the method has the same behavior as {@link #createOMBuilder(Node, boolean)} * and {@link #createOMBuilder(SAXSource, boolean)} with {@code expandEntityReferences} set to * {@code true}. * * @param source * the source of the XML document * @return the builder */ public static OMXMLParserWrapper createOMBuilder(Source source) { OMMetaFactory metaFactory = OMAbstractFactory.getMetaFactory(); return metaFactory.createOMBuilder(metaFactory.getOMFactory(), source); }
/** * Create an object model builder that reads a plain XML document from the provided DOM tree. * * @param node * the DOM node; must be a {@link Node#DOCUMENT_NODE} or {@link Node#ELEMENT_NODE} * @param expandEntityReferences * Determines how {@link EntityReference} nodes are handled: * <ul> * <li>If the parameter is <code>false</code> then a single {@link OMEntityReference} * will be created for each {@link EntityReference}. The child nodes of * {@link EntityReference} nodes are not taken into account. * <li>If the parameter is <code>true</code> then no {@link OMEntityReference} nodes * are created and the children of {@link EntityReference} nodes are converted and * inserted into the Axiom tree. * </ul> * @return the builder */ public static OMXMLParserWrapper createOMBuilder(Node node, boolean expandEntityReferences) { OMMetaFactory metaFactory = OMAbstractFactory.getMetaFactory(); return metaFactory.createOMBuilder(metaFactory.getOMFactory(), node, expandEntityReferences); }
/** * Create an object model builder that reads a plain XML document from the provided * {@link SAXSource}. * * @param source * the source of the XML document * @param expandEntityReferences * Determines how entity references (i.e. {@link LexicalHandler#startEntity(String)} * and {@link LexicalHandler#endEntity(String)} events) are handled: * <ul> * <li>If the parameter is <code>false</code> then a single {@link OMEntityReference} * will be created for each pair of {@link LexicalHandler#startEntity(String)} and * {@link LexicalHandler#endEntity(String)} events. Other events reported between * these two events are not taken into account. * <li>If the parameter is <code>true</code> then no {@link OMEntityReference} nodes * are created and {@link LexicalHandler#startEntity(String)} and * {@link LexicalHandler#endEntity(String)} events are ignored. However, events * between {@link LexicalHandler#startEntity(String)} and * {@link LexicalHandler#endEntity(String)} are processed normally. * </ul> * @return the builder */ public static OMXMLParserWrapper createOMBuilder(SAXSource source, boolean expandEntityReferences) { OMMetaFactory metaFactory = OMAbstractFactory.getMetaFactory(); return metaFactory.createOMBuilder(metaFactory.getOMFactory(), source, expandEntityReferences); }
/** * Create an XOP aware model builder from the provided {@link Attachments} object using a * specified object model factory and with a given parser configuration. * * @param omFactory * the object model factory to use * @param configuration * the parser configuration to use * @param attachments * an {@link Attachments} object that must have been created from an input stream * @return the builder * @throws OMException * if an error occurs while processing the content type information from the * {@link Attachments} object */ public static OMXMLParserWrapper createOMBuilder(OMFactory omFactory, StAXParserConfiguration configuration, Attachments attachments) { ContentType contentType; try { contentType = new ContentType(attachments.getRootPartContentType()); } catch (ParseException ex) { throw new OMException(ex); } InputSource rootPart = getRootPartInputSource(attachments, contentType); return omFactory.getMetaFactory().createOMBuilder(configuration, omFactory, rootPart, new AttachmentsMimePartProvider(attachments)); }