Refine search
protected final Set<Statement> readExpectedGraphQueryResult() throws Exception { RDFFormat rdfFormat = Rio.getParserFormatForFileName(resultFileURL).orElseThrow( Rio.unsupportedFormat(resultFileURL)); RDFParser parser = Rio.createParser(rdfFormat); parser.setDatatypeHandling(DatatypeHandling.IGNORE); parser.setPreserveBNodeIDs(true); parser.setValueFactory(dataRep.getValueFactory()); Set<Statement> result = new LinkedHashSet<Statement>(); parser.setRDFHandler(new StatementCollector(result)); InputStream in = new URL(resultFileURL).openStream(); try { parser.parse(in, resultFileURL); } finally { in.close(); } return result; }
public static void main(String[] args) throws IOException, RDFParseException, RDFHandlerException, UnsupportedRDFormatException { if (args.length < 2) { System.out.println("Usage: java org.openrdf.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); } }
/** * Writes the given single statement to the given {@link Writer} in the given * format. * <p> * * @param statement * A statement to be written. * @param output * The {@link Writer} to write the statement to. * @param dataFormat * The {@link RDFFormat} to use when writing the statement. * @param settings * The {@link WriterConfig} containing settings for configuring the * writer. * @throws RDFHandlerException * Thrown if there is an error writing the statement. * @throws UnsupportedRDFormatException * If no {@link RDFWriter} is available for the specified RDF format. * @since 2.8.0 */ public static void write(Statement statement, Writer output, RDFFormat dataFormat, WriterConfig settings) throws RDFHandlerException { final RDFWriter writer = Rio.createWriter(dataFormat, output); writer.setWriterConfig(settings); write(statement, writer); }
public Document parseRDF(String filename) throws RDFParseException, RDFHandlerException, IOException, JAXBException { // System.out.println("**** Parse "+filename); File file = new File(filename); URL documentURL = file.toURI().toURL(); InputStream inputStream = documentURL.openStream(); RDFParser rdfParser = Rio.createParser(Rio.getParserFormatForFileName(file.getName())); String streamName = documentURL.toString(); return parseRDF(inputStream, rdfParser, streamName); }
/** * @param data * @param out * @param mediaType */ private void writeRdf(Model data, OutputStream out, MediaType mediaType) { RDFFormat rdfFormat = Rio.getWriterFormatForMIMEType(mediaType.toString()); if(rdfFormat == null){ throw new IllegalStateException("JAX-RS called for unsupported mediaType '" + mediaType +"'! If this is a valid RDF type this indicates a missing " + "Sesame Serializer implementation. Otherwise please report this " + "as a bug for the Stanbol Issue Tracker."); } try { Rio.write(data, out, rdfFormat); } catch (RDFHandlerException e) { throw new WebApplicationException("Unable to serialize QueryResultList with requested Format '" + rdfFormat +"'!", e); } }
protected List<Statement> loadData(final String fileName) throws Exception { Optional<RDFFormat> format = RDFParserRegistry.getInstance().getFileFormatForFileName(fileName); if (!format.isPresent()) { throw new IllegalStateException("unsupported file extension"); } RDFParser p = Rio.createParser(format.get()); p.getParserConfig().set(BasicParserSettings.FAIL_ON_UNKNOWN_DATATYPES, false); List<Statement> c = new LinkedList<>(); p.setRDFHandler(new StatementCollector(c)); InputStream in = fileName.startsWith("/") ? new FileInputStream(new File(fileName)) : RDFStreamProcessor.class.getResourceAsStream(fileName); p.parse(in, BASE_IRI); in.close(); return c; }
public static void loadDataset(IDataset dataset, InputStream rdf, RDFFormat format,String baseURI,int batchSize) throws Exception { DatasetStatementCollection sc = new DatasetStatementCollection(batchSize,dataset); RDFParser parser = Rio.createParser(format); parser.setRDFHandler(sc); parser.setValueFactory(Constants.valueFactory); parser.parse(rdf,baseURI); }
public static void parse(final InputStream is, final RDFSink sink, final String baseUri, final RDFFormat format) throws RippleException { RDFParser parser = Rio.createParser(format); parser.setRDFHandler(new SesameInputAdapter(sink)); try { parser.parse(is, baseUri); } catch (IOException | RDFParseException | RDFHandlerException e) { throw new RippleException(e); } } }
private Collection<Annotation> parseInput(final Representation entity) throws ResourceException final RDFFormat inputFormat = Rio.getParserFormatForMIMEType(entity.getMediaType().getName()); final RDFParser parser = Rio.createParser(inputFormat); parser.setRDFHandler(new StatementCollector(input)); try parser.parse(entity.getStream(), "");
private void testSES2030BNodeCollisionsInternal(boolean preserveBNodeIDs) throws Exception { ByteArrayOutputStream output = new ByteArrayOutputStream(); RDFWriter rdfWriter = rdfWriterFactory.getWriter(output); setupWriterConfig(rdfWriter.getWriterConfig()); rdfWriter.startRDF(); int count = 18; for (int i = 0; i < count; i++) { BNode bNode2 = vf.createBNode("a" + Integer.toHexString(i).toUpperCase()); // System.out.println(bNode2.getID()); rdfWriter.handleStatement(vf.createStatement(uri1, uri2, bNode2)); } rdfWriter.endRDF(); RDFParser rdfParser = rdfParserFactory.getParser(); setupParserConfig(rdfParser.getParserConfig()); if (preserveBNodeIDs) { rdfParser.getParserConfig().set(BasicParserSettings.PRESERVE_BNODE_IDS, true); } Model parsedModel = new LinkedHashModel(); rdfParser.setRDFHandler(new StatementCollector(parsedModel)); rdfParser.parse(new ByteArrayInputStream(output.toByteArray()), ""); // if(potentialObjects.size() != parsedModel.size()) { if (count != parsedModel.size()) { Rio.write(parsedModel, System.out, RDFFormat.NQUADS); } assertEquals(count, parsedModel.size()); // assertEquals(potentialObjects.size(), parsedModel.size()); }
@Override public void exportFormalToWriter( PrintWriter out ) throws IOException { RDFWriter rdfWriter = Rio.createWriter( RDFFormat.RDFXML, out ); exportToWriter( rdfWriter ); }
/** * Creates a new RDFParserBase that will use the supplied ValueFactory to * create RDF model objects. * * @param valueFactory A ValueFactory. */ public GeonamesParser(ValueFactory valueFactory) { super(valueFactory); lineParser = Rio.createParser(RDFFormat.RDFXML); lineParser.setParseErrorListener(this); lineParser.setValueFactory(valueFactory); lineParser.setParserConfig(getParserConfig()); }
/** * Choose the parser based on the {@link RDFFormat} specified to the * constructor. * * @return The parser. */ final protected RDFParser getParser(final RDFFormat rdfFormat) { final RDFParser parser = Rio.createParser(rdfFormat, valueFactory); parser.setValueFactory(valueFactory); return parser; }
/** * Creates a new RDFParserBase that will use a {@link org.openrdf.model.impl.ValueFactoryImpl} to * create RDF model objects. */ public GeonamesParser() { super(); lineParser = Rio.createParser(RDFFormat.RDFXML); lineParser.setParseErrorListener(this); lineParser.setParserConfig(getParserConfig()); }
public VerbatimRdfizer(final RDFFormat format, final RDFParser.DatatypeHandling datatypeHandling) { this.format = format; parser = Rio.createParser(format); parser.setDatatypeHandling(datatypeHandling); }
final RDFFormat outputFormat = Rio.getWriterFormatForMIMEType(mimeType, RDFFormat.RDFXML); final RDFHandler output = Rio.createWriter(outputFormat, writer);
/** Parse from input stream, no base uri specified. */ public Document parseRDF(InputStream inputStream, RDFFormat format, String baseuri) throws RDFParseException, RDFHandlerException, IOException { RDFParser rdfParser = Rio.createParser(format); return parseRDF(inputStream, rdfParser, baseuri); }
@Test public void testParserFactoryRegisteredAlternate() { final RDFFormat fmt = Rio.getParserFormatForMIMEType("application/json"); Assert.assertNotNull("Could not find the RDF/JSON RDFFormat instance", fmt); final RDFParser parser = Rio.createParser(fmt); Assert.assertTrue(parser instanceof RDFJSONParser); }
/** * Create a parser for the given format, turning off some of the stricter configuration settings so we * can handle more messy data without errors. * @param format * @return */ private RDFParser createParser(RDFFormat format) { RDFParser parser = Rio.createParser(format); parser.getParserConfig().addNonFatalError(BasicParserSettings.VERIFY_DATATYPE_VALUES); parser.getParserConfig().addNonFatalError(BasicParserSettings.FAIL_ON_UNKNOWN_DATATYPES); parser.getParserConfig().addNonFatalError(BasicParserSettings.NORMALIZE_DATATYPE_VALUES); return parser; }
public void toRDF(File file, RDFFormat format) throws RDFHandlerException, IOException { Writer writer = Files.newWriter(file, Charset.forName("UTF-8")); Rio.write(model, writer, format); writer.flush(); writer.close(); }