/** * Configure schema validation as recommended by the JAXP 1.2 spec. * The <code>properties</code> object may contains information about * the schema local and language. * @param properties parser optional info */ private static void configureOldXerces(SAXParser parser, Properties properties) throws ParserConfigurationException, SAXNotSupportedException { String schemaLocation = (String)properties.get("schemaLocation"); String schemaLanguage = (String)properties.get("schemaLanguage"); try{ if (schemaLocation != null) { parser.setProperty(JAXP_SCHEMA_LANGUAGE, schemaLanguage); parser.setProperty(JAXP_SCHEMA_SOURCE, schemaLocation); } } catch (SAXNotRecognizedException e){ log.info(parser.getClass().getName() + ": " + e.getMessage() + " not supported."); } }
private String getSessionId() throws IOException, ParserConfigurationException, SAXException, NoSuchAlgorithmException { HttpURLConnection con = createConnection(SID_REQUEST_URL); handleResponseCode(con.getResponseCode()); Document doc = xmlFactory.newDocumentBuilder().parse(con.getInputStream()); logger.trace("response:\n{}", XmlUtils.docToString(doc, true)); if (doc == null) { throw new IOException("SessionInfo element not available"); } String sid = XmlUtils.getValue(doc.getDocumentElement(), "SID"); if (EMPTY_SID.equals(sid)) { String challenge = XmlUtils.getValue(doc.getDocumentElement(), "Challenge"); sid = getSessionId(challenge); } if (sid == null || EMPTY_SID.equals(sid)) { throw new IOException("sid request failed: " + sid); } return sid; }
/** * Compare contents of golden file with test output file by their document * representation. * Here we ignore the white space and comments. return true if they're * lexical identical. * @param goldfile Golden output file name. * @param resultFile Test output file name. * @return true if two file's document representation are identical. * false if two file's document representation are not identical. * @throws javax.xml.parsers.ParserConfigurationException if the * implementation is not available or cannot be instantiated. * @throws SAXException If any parse errors occur. * @throws IOException if an I/O error occurs reading from the file or a * malformed or unmappable byte sequence is read . */ public static boolean compareDocumentWithGold(String goldfile, String resultFile) throws ParserConfigurationException, SAXException, IOException { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.setNamespaceAware(true); factory.setCoalescing(true); factory.setIgnoringElementContentWhitespace(true); factory.setIgnoringComments(true); DocumentBuilder db = factory.newDocumentBuilder(); Document goldD = db.parse(Paths.get(goldfile).toFile()); goldD.normalizeDocument(); Document resultD = db.parse(Paths.get(resultFile).toFile()); resultD.normalizeDocument(); return goldD.isEqualNode(resultD); }
public PomModifier(final Path projectDirectory, final Path gitDirectory) { if (builderFactory == null) { builderFactory = DocumentBuilderFactory.newInstance(); transformerFactory = TransformerFactory.newInstance(); try { builder = builderFactory.newDocumentBuilder(); transformer = transformerFactory.newTransformer(); transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no"); transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8"); transformer.setOutputProperty(OutputKeys.INDENT, "yes"); transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4"); } catch (ParserConfigurationException | TransformerConfigurationException e) { throw new IllegalStateException(e); } } this.projectPomFile = gitDirectory.resolve("pom.xml"); this.projectDirectory = projectDirectory; this.gitDirectory = gitDirectory; }
public PepXMLParser(LCMSID singleLCMSID, String FileName, float threshold, boolean CorrectMassDiff) throws ParserConfigurationException, SAXException, IOException, XmlPullParserException { this.singleLCMSID = singleLCMSID; this.CorrectMassDiff = CorrectMassDiff; this.FileName = FileName; this.threshold = threshold; Logger.getRootLogger().info("Parsing pepXML: " + FileName + "...."); try { ParseSAX(); } catch (Exception e) { Logger.getRootLogger().error(ExceptionUtils.getStackTrace(e)); Logger.getRootLogger().info("Parsing pepXML: " + FileName + " failed. Trying to fix the file..."); insert_msms_run_summary(new File(FileName)); ParseSAX(); } //System.out.print("done\n"); }
public static void saveUserDefinedProperties() throws XMLException { Document doc; try { doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument(); } catch (ParserConfigurationException var4) { throw new XMLException("Failed to create document: " + var4, var4); } Element root = doc.createElement("drivers"); doc.appendChild(root); Iterator var2 = getJDBCProperties().iterator(); while(var2.hasNext()) { JDBCProperties props = (JDBCProperties)var2.next(); if(props.isUserDefined()) { root.appendChild(props.getXML(doc)); } } XMLTools.stream(doc, getUserJDBCPropertiesFile(), StandardCharsets.UTF_8); }
public static void parse( URL xmlURL, URL schema, DefaultHandler handler) throws SAXException, IOException, ParserConfigurationException { InputStream xmlStream = URLHandlerRegistry.getDefault().openStream(xmlURL); try { InputSource inSrc = new InputSource(xmlStream); inSrc.setSystemId(xmlURL.toExternalForm()); parse(inSrc, schema, handler); } finally { try { xmlStream.close(); } catch (IOException e) { // ignored } } }
/** * Starts preview lesson on LAMS server. Launches it. */ private void start(HttpServletRequest request, HttpServletResponse response, Context ctx) throws IOException, ServletException, PersistenceException, ParseException, ValidationException, ParserConfigurationException, SAXException { BbPersistenceManager bbPm = PersistenceServiceFactory.getInstance().getDbPersistenceManager(); //store newly created LAMS lesson User user = ctx.getUser(); BlackboardUtil.storeBlackboardContent(request, response, user); // constuct strReturnUrl String courseIdStr = request.getParameter("course_id"); String contentIdStr = request.getParameter("content_id"); // internal Blackboard IDs for the course and parent content item Id courseId = bbPm.generateId(Course.DATA_TYPE, courseIdStr); Id folderId = bbPm.generateId(CourseDocument.DATA_TYPE, contentIdStr); String returnUrl = PlugInUtil.getEditableContentReturnURL(folderId, courseId); request.setAttribute("returnUrl", returnUrl); request.getRequestDispatcher("/modules/startLessonSuccess.jsp").forward(request, response); }
private void parseMavenMetadataInto(ExternalResource metadataResource, final MavenMetadata mavenMetadata) { LOGGER.debug("parsing maven-metadata: {}", metadataResource); metadataResource.withContent(new ErroringAction<InputStream>() { public void doExecute(InputStream inputStream) throws ParserConfigurationException, SAXException, IOException { XMLHelper.parse(inputStream, null, new ContextualSAXHandler() { public void endElement(String uri, String localName, String qName) throws SAXException { if ("metadata/versioning/snapshot/timestamp".equals(getContext())) { mavenMetadata.timestamp = getText(); } if ("metadata/versioning/snapshot/buildNumber".equals(getContext())) { mavenMetadata.buildNumber = getText(); } if ("metadata/versioning/versions/version".equals(getContext())) { mavenMetadata.versions.add(getText().trim()); } super.endElement(uri, localName, qName); } }, null); } }); }
public static Document buildDOMderivation(ArrayList<ParseTreeCollection> all, String sentence) { try { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder constructor = factory.newDocumentBuilder(); derivDoc = constructor.newDocument(); derivDoc.setXmlVersion("1.0"); derivDoc.setXmlStandalone(false); Element root = derivDoc.createElement("parses"); root.setAttribute("sentence", sentence); for (ParseTreeCollection ptc : all) { buildOne(root, ptc.getDerivationTree().getDomNodes().get(0), ptc.getDerivedTree().getDomNodes().get(0), ptc.getSemantics(), ptc.getSpecifiedSemantics()); } // finally we do not forget the root derivDoc.appendChild(root); return derivDoc; } catch (ParserConfigurationException e) { System.err.println(e); return null; } }
/** * Creates a DOM (Document Object Model) <code>Document<code>. */ private void createDOM() { try { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder builder = factory.newDocumentBuilder(); //data is a Document Document data = builder.newDocument(); Element root = data.createElement("measure"); root.setAttribute("name", name); root.setAttribute("meanValue", "null"); root.setAttribute("upperBound", "null"); root.setAttribute("lowerBound", "null"); root.setAttribute("progress", Double.toString(getSamplesAnalyzedPercentage())); root.setAttribute("data", "null"); root.setAttribute("finished", "false"); root.setAttribute("discarded", "0"); root.setAttribute("precision", Double.toString(analyzer.getPrecision())); root.setAttribute("maxSamples", Double.toString(getMaxSamples())); data.appendChild(root); } catch (FactoryConfigurationError factoryConfigurationError) { factoryConfigurationError.printStackTrace(); } catch (ParserConfigurationException e) { e.printStackTrace(); } }
private static void saveOperatorDocBundle(File file) { try { Document document = DocumentBuilderFactory .newInstance() .newDocumentBuilder() .newDocument(); document.setXmlVersion("1.0"); document.setXmlStandalone(false); Attr attr = document.createAttribute("encoding"); attr.setValue("UTF-8"); Element operatorHelp = document.createElement("operatorHelp"); for (OperatorDescription deac: getAllUserDefinedOperators()) { addOperatorDoc(document, operatorHelp, deac.getName(), deac.getKey()); } document.appendChild(operatorHelp); XMLTools.stream(document, file, Charset.forName("UTF-8")); } catch (ParserConfigurationException | XMLException e) { SwingTools.showSimpleErrorMessage(ioErrorKey, e); } }
/** * Process the xmlfile named <code>fileName</code> with the given system * ID. * * @param fileName * meta data file name. * @param systemId * system ID. */ protected void processFile(String fileName, String systemId) throws ValidationException, ParserConfigurationException, SAXException, IOException, SchedulerException, ClassNotFoundException, ParseException, XPathException { prepForProcessing(); log.info("Parsing XML file: " + fileName + " with systemId: " + systemId); InputSource is = new InputSource(getInputStream(fileName)); is.setSystemId(systemId); process(is); maybeThrowValidationException(); }
private static NodeList get_node_list(List<String> xml_lines, String addition) { StringBuilder sb = new StringBuilder(); for(String line : xml_lines) { sb.append(line); } String xml_string = sb.toString(); try { DocumentBuilder db = DocumentBuilderFactory.newInstance().newDocumentBuilder(); InputSource is = new InputSource(); is.setCharacterStream(new StringReader(xml_string)); Document doc = db.parse(is); if(!addition.equals("")) { addition = addition + ":"; } return doc.getElementsByTagName(addition + "infoTable"); } catch (ParserConfigurationException | IOException | SAXException e) { e.printStackTrace(); } return null; }
protected String migrateBillingResultXml(String billingXml) throws ParserConfigurationException, SAXException, IOException, XPathExpressionException, TransformerException { // create a document from the xml file Document document = XMLConverter.convertToDocument(billingXml, false); // iterate over all stepped prices elements, if any NodeList steppedPrices = XMLConverter.getNodeListByXPath(document, XPATH_STEPPEDPRICES); for (int i = 0; i < steppedPrices.getLength(); i++) { Node steppedPricesElement = steppedPrices.item(i); // proceed only if amount attribute is not present if (!isAmountAttributeAlreadyPresent(steppedPricesElement)) { long value = getValue(steppedPricesElement); StepData relevantStep = getStepData(steppedPricesElement, value); BigDecimal price = calculateStepPrice(relevantStep); createAttribute(steppedPricesElement, price); } } return XMLConverter.convertToString(document, false); }
@SuppressWarnings("unchecked") public T createDefaultInstance(final FallbackConfigProvider fallback) throws ConfigXMLReaderException, URISyntaxException, ParserConfigurationException, XMLStreamException, SAXException, IOException { YangInstanceIdentifier yangPath = bindingSerializer.toYangInstanceIdentifier(bindingContext.appConfigPath); LOG.debug("{}: Creating app config instance from path {}, Qname: {}", logName, yangPath, bindingContext.bindingQName); checkNotNull(schemaService, "%s: Could not obtain the SchemaService OSGi service", logName); SchemaContext schemaContext = schemaService.getGlobalContext(); Module module = schemaContext.findModuleByNamespaceAndRevision(bindingContext.bindingQName.getNamespace(), bindingContext.bindingQName.getRevision()); checkNotNull(module, "%s: Could not obtain the module schema for namespace %s, revision %s", logName, bindingContext.bindingQName.getNamespace(), bindingContext.bindingQName.getRevision()); DataSchemaNode dataSchema = module.getDataChildByName(bindingContext.bindingQName); checkNotNull(dataSchema, "%s: Could not obtain the schema for %s", logName, bindingContext.bindingQName); checkCondition(bindingContext.schemaType.isAssignableFrom(dataSchema.getClass()), "%s: Expected schema type %s for %s but actual type is %s", logName, bindingContext.schemaType, bindingContext.bindingQName, dataSchema.getClass()); NormalizedNode<?, ?> dataNode = parsePossibleDefaultAppConfigXMLFile(schemaContext, dataSchema); if (dataNode == null) { dataNode = fallback.get(schemaService.getGlobalContext(), dataSchema); } DataObject appConfig = bindingSerializer.fromNormalizedNode(yangPath, dataNode).getValue(); // This shouldn't happen but need to handle it in case... checkNotNull(appConfig, "%s: Could not create instance for app config binding %s", logName, bindingContext.appConfigBindingClass); return (T) appConfig; }
/** * Loads a xml document from its {@link String} representation without doing xml validation and * return a {@link XmlDocument} * @param sourceLocation the source location to use for logging and record collection. * @param xml the persisted xml. * @return the initialized {@link XmlDocument} * @throws IOException this should never be thrown. * @throws SAXException if the xml is incorrect * @throws ParserConfigurationException if the xml engine cannot be configured. */ public static XmlDocument load( KeyResolver<String> selectors, KeyBasedValueResolver<SystemProperty> systemPropertyResolver, SourceLocation sourceLocation, String xml, XmlDocument.Type type, Optional<String> mainManifestPackageName) throws IOException, SAXException, ParserConfigurationException { PositionXmlParser positionXmlParser = new PositionXmlParser(); Document domDocument = positionXmlParser.parse(xml); return domDocument != null ? new XmlDocument( positionXmlParser, sourceLocation, selectors, systemPropertyResolver, domDocument.getDocumentElement(), type, mainManifestPackageName) : null; }
private void MS1PeakDetection() throws SQLException, InterruptedException, ExecutionException, IOException, ParserConfigurationException, SAXException, FileNotFoundException, Exception { //Remove existing pseudo MS/MS MGF files RemoveMGF(); MS1FeatureMap = new LCMSPeakMS1(Filename, NoCPUs); MS1FeatureMap.datattype = dIA_Setting.dataType; MS1FeatureMap.SetParameter(parameter); MS1FeatureMap.Resume = Resume; //Assign MS1 feature maps MS1FeatureMap.SetMS1Windows(dIA_Setting.MS1Windows); MS1FeatureMap.CreatePeakFolder(); MS1FeatureMap.ExportPeakCurveTable = false; MS1FeatureMap.SetSpectrumParser(GetSpectrumParser()); Logger.getRootLogger().info("Processing MS1 peak detection"); MS1FeatureMap.ExportPeakClusterTable = ExportPrecursorPeak; //Start MS1 feature detection MS1FeatureMap.PeakClusterDetection(); Logger.getRootLogger().info("=================================================================================="); }
/** * Removes "debug" tag from file * * @param file AndroidManifest file * @throws AndrolibException */ public static void removeApplicationDebugTag(File file) throws AndrolibException { if (file.exists()) { try { Document doc = loadDocument(file); Node application = doc.getElementsByTagName("application").item(0); // load attr NamedNodeMap attr = application.getAttributes(); Node debugAttr = attr.getNamedItem("android:debuggable"); // remove application:debuggable if (debugAttr != null) { attr.removeNamedItem("android:debuggable"); } saveDocument(file, doc); } catch (SAXException | ParserConfigurationException | IOException | TransformerException ignored) { } } }
/** * Parse the input source and return a Document. * @param source The {@code InputSource} of the document * @return a DOM Document * @throws XPathExpressionException if there is an error parsing the source. */ Document getDocument(InputSource source) throws XPathExpressionException { requireNonNull(source, "Source"); try { // we'd really like to cache those DocumentBuilders, but we can't because: // 1. thread safety. parsers are not thread-safe, so at least // we need one instance per a thread. // 2. parsers are non-reentrant, so now we are looking at having a // pool of parsers. // 3. then the class loading issue. The look-up procedure of // DocumentBuilderFactory.newInstance() depends on context class loader // and system properties, which may change during the execution of JVM. // // so we really have to create a fresh DocumentBuilder every time we need one // - KK DocumentBuilderFactory dbf = FactoryImpl.getDOMFactory(useServiceMechanism); dbf.setNamespaceAware(true); dbf.setValidating(false); return dbf.newDocumentBuilder().parse(source); } catch (ParserConfigurationException | SAXException | IOException e) { throw new XPathExpressionException (e); } }
/** * @return an instance of DOM Document */ private static Document getDocument() { try { if (System.getSecurityManager() == null) { return DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument(); } else { return DocumentBuilderFactory.newInstance(JDK_DEFAULT_DOM, null).newDocumentBuilder().newDocument(); } } catch(ParserConfigurationException pce) { throw new com.sun.org.apache.xml.internal.utils.WrappedRuntimeException(pce); } }
private XMLReader createReader() throws SAXException { try { SAXParserFactory pfactory = SAXParserFactory.newInstance(); pfactory.setValidating(true); pfactory.setNamespaceAware(true); // Enable schema validation SchemaFactory sfactory = SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema"); InputStream stream = Parser.class.getResourceAsStream("graphdocument.xsd"); pfactory.setSchema(sfactory.newSchema(new Source[]{new StreamSource(stream)})); return pfactory.newSAXParser().getXMLReader(); } catch (ParserConfigurationException ex) { throw new SAXException(ex); } }
@Test public void signRequest() throws JAXBException, ParserConfigurationException, CertificateException, KeyException, MarshalException, NoSuchAlgorithmException, SOAPException, XPathExpressionException, XMLSignatureException, InvalidAlgorithmParameterException, java.security.cert.CertificateException, NoSuchProviderException, KeyStoreException, IOException, UnrecoverableKeyException { Serializable payload = createRequest(); SOAPMessage signedRequest = sign( marshall( payload, getMarshaller(payload.getClass()) ), getClient() ); System.out.println("============ SIGNED SOAP MESSAGE ================"); signedRequest.writeTo(System.out); System.out.println("\n================================================="); }
public static String convertToAndroidLayout(InputSource source) throws ParserConfigurationException, IOException, SAXException { StringBuilder layoutXml = new StringBuilder(); DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder builder = factory.newDocumentBuilder(); Document document = builder.parse(source); handleNode(document.getFirstChild(), "xmlns:android=\"http://schemas.android.com/apk/res/android\"", layoutXml); return layoutXml.toString(); }
private NSDictionary read(final Local file) { try { return (NSDictionary) XMLPropertyListParser.parse(file.getInputStream()); } catch(ParserConfigurationException | IOException | SAXException | PropertyListFormatException | ParseException | AccessDeniedException e) { log.warn(String.format("Failure %s reading dictionary from %s", e.getMessage(), file)); } return null; }
/** * <p>Creates a new instance of SAX2DOMBuilder, which creates * a new document. The document is available via * {@link #getDocument()}.</p> * @throws javax.xml.parsers.ParserConfigurationException */ public SAX2DOMBuilder() throws ParserConfigurationException { DocumentBuilderFactory documentBuilderFactory; DocumentBuilder documentBuilder; documentBuilderFactory = DocumentBuilderFactory.newInstance(); documentBuilderFactory.setValidating(false); documentBuilderFactory.setNamespaceAware(true); documentBuilder = documentBuilderFactory.newDocumentBuilder(); this.document = documentBuilder.newDocument(); this.currentNode = this.document; }
public SAXParser get() throws ParserConfigurationException, SAXException { try { return (SAXParser) queue.take(); } catch (InterruptedException ex) { throw new SAXException(ex); } }
/** * @param dubboConfigFilePath * @return HashMap, key protocol id, value "dubbo" or "http" */ protected static HashMap<String, String> getDubboProtocols(String dubboConfigFilePath) throws IOException, SAXException, ParserConfigurationException, XPathExpressionException { HashMap<String, String> result = new HashMap<>(); if(!StringUtils.isEmpty(dubboConfigFilePath)) { Document dubboConfig = readXMLConfig(dubboConfigFilePath); XPath xPath = XPathFactory.newInstance().newXPath(); xPath.setNamespaceContext(new UniversalNamespaceCache(dubboConfig, false)); NodeList serviceNodes = (NodeList) xPath.evaluate( "//:beans/dubbo:protocol", dubboConfig, XPathConstants.NODESET); for (int i = 0; i < serviceNodes.getLength(); i++) { Node node = serviceNodes.item(i); String id = getAttributeValue(node, "id"); String name = getAttributeValue(node, "name"); String server = getAttributeValue(node, "server"); if(StringUtils.isEmpty(id)) { id = name; } if("servlet".equalsIgnoreCase(server) || "jetty".equalsIgnoreCase(server)) { result.put(id, "http"); } else { result.put(id, "dubbo"); } } } return result; }
/** * Parses and shows the content of one sheet using the specified styles and * shared-strings tables. * * @param styles * @param strings * @param sheetInputStream */ public void processSheet(StylesTable styles, ReadOnlySharedStringsTable strings, SheetContentsHandler sheetHandler, InputStream sheetInputStream) throws IOException, ParserConfigurationException, SAXException { DataFormatter formatter = new DataFormatter(); InputSource sheetSource = new InputSource(sheetInputStream); try { XMLReader sheetParser = SAXHelper.newXMLReader(); ContentHandler handler = new XSSFSheetXMLHandler(styles, null, strings, sheetHandler, formatter, false); sheetParser.setContentHandler(handler); sheetParser.parse(sheetSource); } catch (ParserConfigurationException e) { throw new RuntimeException("SAX parser appears to be broken - " + e.getMessage()); } }
public LibraryProfiler(File libraryFile, File libDescriptionFile) throws ParserConfigurationException, SAXException, IOException, ParseException { this.libraryFile = libraryFile; // read library description libDesc = XMLParser.readLibraryXML(libDescriptionFile); // set identifier for logging String logIdentifier = CliOptions.logDir.getAbsolutePath() + File.separator; logIdentifier += libDesc.name.replaceAll(" ", "-") + "_" + libDesc.version; MDC.put("appPath", logIdentifier); }
/** * Creates the supplier payment result report containing the status of the * interactions (debiting processes) of BES with the payment service * provider. */ public void buildReport(long supplierKey, VOReportResult result) throws XPathExpressionException, ParserConfigurationException { result.setServerTimeZone(DateConverter.getCurrentTimeZoneAsUTCString()); List<ReportResultData> reportData = paymentDao .retrievePaymentInformationData(supplierKey); ReportDataConverter converter = new ReportDataConverter(subscriptionDao); Map<String, String> columnXPathMap = new HashMap<String, String>(); columnXPathMap.put("processingresult", "/Response/Transaction/Processing/Return/text()"); converter.convertToXml(reportData, result.getData(), columnXPathMap); }
public XMLMerger(OnlineSession appSession) { m_AppSession = appSession ; m_tab = new Hashtable<String, Element>() ; try { m_docBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder(); } catch (ParserConfigurationException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
public static DocumentBuilder getDocumentBuilder() { try { return DocumentBuilderFactory.newInstance().newDocumentBuilder(); } catch(ParserConfigurationException e) { LOG.severe(e.getMessage()); } return null; }
private void processFile(ProcessingContext<Corpus> ctx, Logger logger, Corpus corpus, InputStream file, Transformer transformer) throws ModuleException, IOException { try { String name = sourcePath.getStreamName(file); logger.finer("reading: " + name); transformer.reset(); transformer.setParameter(SOURCE_PATH_PARAMETER, name); transformer.setParameter(SOURCE_BASENAME_PARAMETER, new File(name).getName()); transformer.setParameter(XML_READER_CONTEXT_PARAMETER, new XMLReaderContext(this, corpus)); Source source = getSource(ctx, file); doTransform(ctx, transformer, source); } catch (TransformerException|SAXException|ParserConfigurationException e) { rethrow(e); } }
public DOMForest( InternalizationLogic logic, Options opt ) { if (opt == null) throw new AssertionError("Options object null"); this.options = opt; try { DocumentBuilderFactory dbf = XmlFactory.createDocumentBuilderFactory(opt.disableXmlSecurity); this.documentBuilder = dbf.newDocumentBuilder(); this.parserFactory = XmlFactory.createParserFactory(opt.disableXmlSecurity); } catch( ParserConfigurationException e ) { throw new AssertionError(e); } this.logic = logic; }
private Document documentFactory(String xml) throws SAXException, IOException, ParserConfigurationException { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.setNamespaceAware(true); Document document = factory.newDocumentBuilder().parse(new ByteArrayInputStream(xml.getBytes())); return document; }
@Override public List<GitHubJourneyWidgetDataEntry> parse(String url) throws ParserConfigurationException, IOException, SAXException { DocumentBuilder builder = dBFactory.newDocumentBuilder(); Document xmlDoc = builder.parse(url); NodeList nodeList = xmlDoc.getElementsByTagName("entry"); List<GitHubJourneyWidgetDataEntry> dataEntriesList = new ArrayList<>(nodeList.getLength()); for (int i = 0; i < nodeList.getLength(); i++) { GitHubJourneyWidgetDataEntry entry = parseItem((Element) nodeList.item(i)); dataEntriesList.add(entry); } return dataEntriesList; }
private void saveBlockedProcessesToFile(List<DBBlocksJournalProcess> processes) throws ParserConfigurationException, IOException, SAXException { String fileName = String.format("%s-%s.xml", this.model.getName(), dateUtils.dateToString(blocksJournalCreateDate)); Path blocksJournalsDirPath = PathBuilder.getInstance().getBlocksJournalsDir(); Path currentJournalPath = Paths.get(blocksJournalsDirPath.toString(), fileName); File currentJournalFile = currentJournalPath.toFile(); DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance(); DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder(); boolean fileExists = currentJournalFile.exists(); Document document; Element rootElement; if (fileExists) { document = documentBuilder.parse(currentJournalFile); rootElement = document.getDocumentElement(); } else { document = documentBuilder.newDocument(); rootElement = document.createElement("blocksJournal"); } DBBlocksJournalProcessSerializer serializer = new DBBlocksJournalProcessSerializer(); processes.forEach(journalProcess -> { Element el = serializer.serialize(document, journalProcess); rootElement.appendChild(el); }); if (!fileExists) { document.appendChild(rootElement); } XmlDocumentWorker documentWorker = new XmlDocumentWorker(); documentWorker.save(document, currentJournalFile); }
@Override public PaymentServiceProviderAdapter getPort(String wsdl) throws IOException, WSDLException, ParserConfigurationException { WSPortConnector portConnector = new WSPortConnector(wsdl, null, null); SupportedVersions supportedNS = getSupportedVersion(portConnector); PaymentServiceProviderAdapter adapter = getAdapterForNamespace(supportedNS); final Object port = portConnector.getPort(supportedNS.getLocalWSDL(), supportedNS.getServiceClass(), timeout); adapter.setPaymentServiceProviderService(port); return adapter; }
/** * Returns an instance of XMLReader. * * @return an instance of XMLReader. */ private XMLReader getXMLReader() { XMLReader reader = null; try { reader = SAXParserFactory.newInstance().newSAXParser().getXMLReader(); } catch (ParserConfigurationException | SAXException ex) {} return reader; }