@Override public Set<Statement> deserialize(final String topic, final byte[] data) { if(data == null || data.length == 0) { // Return null because that is the contract of this method. return null; } try { final RDFParser parser = PARSER_FACTORY.getParser(); final Set<Statement> statements = new HashSet<>(); parser.setRDFHandler(new AbstractRDFHandler() { @Override public void handleStatement(final Statement statement) throws RDFHandlerException { log.debug("Statement: " + statement); statements.add( statement ); } }); parser.parse(new ByteArrayInputStream(data), null); return statements; } catch(final RDFParseException | RDFHandlerException | IOException e) { log.error("Could not deserialize a Set of VisibilityStatement objects using the RDF4J Rio Binary format.", e); return null; } }
private void loadAxiomStatements(RDFParser parser, String file) throws SailException { RDFInferencerInserter inserter = new RDFInferencerInserter(this, vf); parser.setRDFHandler(inserter); URL url = getClass().getResource(file); try { InputStream in = new BufferedInputStream(url.openStream()); try { logger.debug("loading axioms statements from {}", file); parser.parse(in, url.toString()); } finally { in.close(); } } catch (IOException ioe) { throw new SailException(ioe); } catch (RDF4JException e) { throw new SailException(e); } }
public static void main(String[] args) throws IOException, RDFParseException, RDFHandlerException, UnsupportedRDFormatException { if (args.length < 2) { System.out.println("Usage: java org.eclipse.rdf4j.rio.Rio <inputFile> <outputFile>"); System.exit(1); return; } String inputFile = args[0]; String outputFile = args[1]; try (FileOutputStream outStream = new FileOutputStream(outputFile); FileInputStream inStream = new FileInputStream(inputFile);) { createParser(getParserFormatForFileName(inputFile).orElse(RDFFormat.RDFXML)).setRDFHandler( createWriter(getWriterFormatForFileName(outputFile).orElse(RDFFormat.RDFXML), outStream)).parse(inStream, "file:" + inputFile); } }
private void loadAxiomStatements(RDFParser parser, String file) throws SailException { RDFInferencerInserter inserter = new RDFInferencerInserter(this, vf); parser.setRDFHandler(inserter); URL url = getClass().getResource(file); try { InputStream in = new BufferedInputStream(url.openStream()); try { logger.debug("loading axioms statements from {}", file); parser.parse(in, url.toString()); } finally { in.close(); } } catch (IOException ioe) { throw new SailException(ioe); } catch (RDF4JException e) { throw new SailException(e); } }
public static void main(String[] args) throws IOException, RDFParseException, RDFHandlerException, UnsupportedRDFormatException { if (args.length < 2) { System.out.println("Usage: java org.eclipse.rdf4j.rio.Rio <inputFile> <outputFile>"); System.exit(1); return; } String inputFile = args[0]; String outputFile = args[1]; try (FileOutputStream outStream = new FileOutputStream(outputFile); FileInputStream inStream = new FileInputStream(inputFile);) { createParser(getParserFormatForFileName(inputFile).orElse(RDFFormat.RDFXML)).setRDFHandler( createWriter(getWriterFormatForFileName(outputFile).orElse(RDFFormat.RDFXML), outStream)).parse(inStream, "file:" + inputFile); } }
public static void main(String[] args) throws IOException, RDFParseException, RDFHandlerException, UnsupportedRDFormatException { if (args.length < 2) { System.out.println("Usage: java org.eclipse.rdf4j.rio.Rio <inputFile> <outputFile>"); System.exit(1); return; } String inputFile = args[0]; String outputFile = args[1]; try (FileOutputStream outStream = new FileOutputStream(outputFile); FileInputStream inStream = new FileInputStream(inputFile);) { createParser(getParserFormatForFileName(inputFile).orElse(RDFFormat.RDFXML)).setRDFHandler( createWriter(getWriterFormatForFileName(outputFile).orElse(RDFFormat.RDFXML), outStream)).parse(inStream, "file:" + inputFile); } }
@Procedure(mode = Mode.READ) public Stream<GraphResult> previewRDFSnippet(@Name("rdf") String rdfFragment, @Name("format") String format, @Name("props") Map<String, Object> props) { final boolean shortenUrls = (props.containsKey("shortenUrls")?(boolean)props.get("shortenUrls"):DEFAULT_SHORTEN_URLS); final boolean typesToLabels = (props.containsKey("typesToLabels")?(boolean)props.get("typesToLabels"):DEFAULT_TYPES_TO_LABELS); final String languageFilter = (props.containsKey("languageFilter")?(String)props.get("languageFilter"):null); Map<String,Node> virtualNodes = new HashMap<>(); List<Relationship> virtualRels = new ArrayList<>(); StatementPreviewer statementViewer = new StatementPreviewer(db, shortenUrls, typesToLabels, virtualNodes, virtualRels, languageFilter, log); try { InputStream inputStream = new ByteArrayInputStream( rdfFragment.getBytes(Charset.defaultCharset()) ); //rdfFragment.openStream(); RDFFormat rdfFormat = getFormat(format); log.info("Data set to be parsed as " + rdfFormat); RDFParser rdfParser = Rio.createParser(rdfFormat); rdfParser.setRDFHandler(statementViewer); rdfParser.parse(inputStream, "http://neo4j.com/base/"); } catch (MalformedURLException e) { e.printStackTrace(); } catch (IOException | RDFHandlerException | QueryExecutionException | RDFParseException | RDFImportPreRequisitesNotMet e) { e.printStackTrace(); } GraphResult graphResult = new GraphResult(new ArrayList<>(virtualNodes.values()), virtualRels); return Stream.of(graphResult); }
@Override public void run() { try { try { parser.setRDFHandler(this); if (charset == null) { parser.parse(in, baseURI); } else { parser.parse(new InputStreamReader(in, charset), baseURI); } } finally { in.close(); } } catch (Exception e) { queue.toss(e); } finally { queue.done(); namespacesReady.countDown(); finishedParsing.countDown(); } }
@Override public void run() { try { try { parser.setRDFHandler(this); if (charset == null) { parser.parse(in, baseURI); } else { parser.parse(new InputStreamReader(in, charset), baseURI); } } finally { in.close(); } } catch (Exception e) { queue.toss(e); } finally { queue.done(); namespacesReady.countDown(); finishedParsing.countDown(); } }
private void translateRDFDocument(final InputStream in, final OutputStream out, final RDFFormat inFormat, final RDFFormat outFormat, final String baseURI) throws SailException, IOException, RDFHandlerException, RDFParseException { RDFParser p = Rio.createParser(inFormat); RDFWriter w = Rio.createWriter(outFormat, out); p.setRDFHandler(w); p.parse(in, baseURI); } }
@Override public void run() { try { try { parser.setRDFHandler(this); if (charset == null) { parser.parse(in, baseURI); } else { parser.parse(new InputStreamReader(in, charset), baseURI); } } finally { in.close(); } } catch (Exception e) { queue.toss(e); } finally { queue.done(); namespacesReady.countDown(); finishedParsing.countDown(); } }
private Model loadModel(String fileName) throws Exception { URL modelURL = this.getClass().getResource(TESTCASES_DIR + fileName); assertNotNull("Test file not found: " + fileName, modelURL); Model model = createEmptyModel(); Optional<RDFFormat> rdfFormat = Rio.getParserFormatForFileName(fileName); assertTrue("Unable to determine RDF format for file: " + fileName, rdfFormat.isPresent()); RDFParser parser = Rio.createParser(rdfFormat.get()); parser.setDatatypeHandling(DatatypeHandling.IGNORE); parser.setPreserveBNodeIDs(true); parser.setRDFHandler(new StatementCollector(model)); InputStream in = modelURL.openStream(); try { parser.parse(in, modelURL.toString()); return model; } finally { in.close(); } }
/** * Constructor to start parsing R2RML mappings from file. * @param file - the File object * @param termFactory * @param typeFactory * @param targetAtomFactory */ public R2RMLManager(File file,TermFactory termFactory, TypeFactory typeFactory, TargetAtomFactory targetAtomFactory) throws MappingIOException, RDFParseException, RDFHandlerException { this.termFactory = termFactory; this.typeFactory = typeFactory; this.targetAtomFactory = targetAtomFactory; try { LinkedHashModel model = new LinkedHashModel(); RDFParser parser = Rio.createParser(RDFFormat.TURTLE); InputStream in = new FileInputStream(file); URL documentUrl = new URL("file://" + file); StatementCollector collector = new StatementCollector(model); parser.setRDFHandler(collector); parser.parse(in, documentUrl.toString()); this.myModel = new RDF4J().asGraph(model); r2rmlParser = new R2RMLParser(termFactory, this.typeFactory); } catch (IOException e) { throw new MappingIOException(e); } }
private Statement parseNtriples(String ntriples) throws IOException, RDFParseException, RDFHandlerException { RDFParser parser = Rio.createParser(RDFFormat.NTRIPLES, vf); parser.setPreserveBNodeIDs(true); StatementCollector collector = new StatementCollector(); parser.setRDFHandler(collector); parser.parse(new StringReader(ntriples), "http://example.com/"); Statement st = collector.getStatements().iterator().next(); return st; }
/** * Parses the content of <code>is</code> input stream with the * specified parser <code>p</code> using <code>baseIRI</code>. * * @param format input format type. * @param is input stream containing <code>RDF</code>. * @param baseIRI base uri. * @return list of statements detected within the input stream. * @throws IOException if there is an error reading the {@link java.io.InputStream} */ public static Statement[] parseRDF(RDFFormat format, InputStream is, String baseIRI) throws IOException { final StatementCollector handler = new StatementCollector(); final RDFParser parser = getParser(format); parser.getParserConfig().set(BasicParserSettings.VERIFY_DATATYPE_VALUES, true); parser.setStopAtFirstError(true); parser.setPreserveBNodeIDs(true); parser.setRDFHandler(handler); parser.parse(is, baseIRI); return handler.getStatements().toArray( new Statement[handler.getStatements().size()] ); }
@Override public void handleResponse(HttpMethod method) throws IOException, AGHttpException { String mimeType = getResponseMIMEType(method); if (!mimeType.equals(getRequestMIMEType())) { throw new AGHttpException("unexpected response MIME type: " + mimeType); } InputStream response = getInputStream(method); // Note: we ignore charset specified in the response. Reader reader = new InputStreamReader(response, StandardCharsets.UTF_8); try { RDFParser parser = Rio.createParser(format, vf); parser.setPreserveBNodeIDs(true); parser.setRDFHandler(rdfhandler); parser.parse(reader, method.getURI().getURI()); } catch (RDFParseException | RDFHandlerException e) { throw new AGHttpException(e); } }
public boolean addContext(Context context) { try { RepositoryConnection conn = getConnection(); { ValueFactory vf = conn.getValueFactory(); RDFParser rdfParser = getParser(context.getRdfFormat()); StatementCollector handler = new StatementCollector(); rdfParser.setRDFHandler(handler); rdfParser.parse(context.getInputStream(), context.getBaseUri()); Collection<Statement> col = handler.getStatements(); Iterator<Statement> it = col.iterator(); while(it.hasNext()) { org.eclipse.rdf4j.model.Statement statement = it.next(); conn.add(statement, vf.createURI(context.getContextId())); } } closeConnection(conn); return true; } catch (Exception e) { e.printStackTrace(); return false; } }
protected void loadDataset(String datasetFile) throws RDFParseException, RepositoryException, IOException { logger.debug("loading dataset..."); InputStream dataset = org.eclipse.rdf4j.query.parser.sparql.SPARQLUpdateTest.class.getResourceAsStream(datasetFile); try { RDFParser parser = Rio.createParser(RDFFormat.TRIG, f); parser.setPreserveBNodeIDs(true); StatementCollector collector = new StatementCollector(); parser.setRDFHandler(collector); parser.parse(dataset, ""); con.add(collector.getStatements()); } catch (RDFParseException e) { throw new RuntimeException(e); } catch (RDFHandlerException e) { throw new RuntimeException(e); } finally { dataset.close(); } }
@Override public void run() { org.eclipse.rdf4j.rio.RDFParser rdfParser = Rio .createParser(format); if (this.config != null) { rdfParser.setParserConfig(config); } rdfParser.setRDFHandler(new RDFListener(buffer)); try { rdfParser.parse(this.reader, ""); } catch (RDFParseException e) { throw new ParseError("An error occured while parsing", e); } catch (RDFHandlerException e) { throw new ParseError("An error occured while parsing", e); } catch (IOException e) { throw new ParseError("An error occured while parsing", e); } buffer.close(); try { this.reader.close(); } catch (IOException e) { } } }
private Model parseTurtleGraph(final String configFile) throws IOException, RDFParseException, RDFHandlerException, FileNotFoundException { RDFParser parser = Rio.createParser(RDFFormat.TURTLE, vf); parser.setPreserveBNodeIDs(true); StatementCollector collector = new StatementCollector(); parser.setRDFHandler(collector); try (final InputStream fis = Util.resourceAsStream(configFile)) { parser.parse(fis, ""); } return new LinkedHashModel(collector.getStatements()); }