Java Code Examples for org.openrdf.rio.Rio#createParser()

protected Graph parseConfig(File file) throws SailConfigException, IOException {

        RDFFormat format = Rio.getParserFormatForFileName(file.getAbsolutePath());
        if (format==null)
            throw new SailConfigException("Unsupported file format: " + file.getAbsolutePath());
        RDFParser parser = Rio.createParser(format);
        Graph model = new GraphImpl();
        parser.setRDFHandler(new StatementCollector(model));
        InputStream stream = new FileInputStream(file);

        try {
            parser.parse(stream, file.getAbsolutePath());
        } catch (Exception e) {
            throw new SailConfigException("Error parsing file!");
        }

        stream.close();
        return model;
    }
 

private void addData(final RepositoryConnection conn) throws IOException,
		RDFParseException, RepositoryException, RDFHandlerException {

    final RDFParser rdfParser = Rio.createParser(RDFFormat.NTRIPLES,
			conn.getValueFactory());
	rdfParser.setVerifyData(true);
	rdfParser.setStopAtFirstError(true);
	rdfParser.setDatatypeHandling(RDFParser.DatatypeHandling.IGNORE);
	rdfParser.setRDFHandler(new RDFHandlerBase() {
		@Override
		public void handleStatement(Statement st)
				throws RDFHandlerException {
			try {
				conn.add(st);
			} catch (OpenRDFException e) {
				throw new RDFHandlerException(e);
			}
		}
	});
	rdfParser.parse(getClass().getResourceAsStream("TestTicket276.n3"), "");
}
 

protected void upload(URI graphURI, Resource context)
	throws Exception
{
	RepositoryConnection con = dataRep.getConnection();

	try {
		con.begin();
		RDFFormat rdfFormat = Rio.getParserFormatForFileName(graphURI.toString(), RDFFormat.TURTLE);
		RDFParser rdfParser = Rio.createParser(rdfFormat, dataRep.getValueFactory());
		rdfParser.setVerifyData(false);
		rdfParser.setDatatypeHandling(DatatypeHandling.IGNORE);
		// rdfParser.setPreserveBNodeIDs(true);

		RDFInserter rdfInserter = new RDFInserter(con);
		rdfInserter.enforceContext(context);
		rdfParser.setRDFHandler(rdfInserter);

		URL graphURL = new URL(graphURI.toString());
		InputStream in = graphURL.openStream();
		try {
			rdfParser.parse(in, graphURI.toString());
		}
		finally {
			in.close();
		}

		con.commit();
	}
	catch (Exception e) {
		if (con.isActive()) {
			con.rollback();
		}
		throw e;
	}
	finally {
		con.close();
	}
}
 

protected final Set<Statement> readExpectedGraphQueryResult()
	throws Exception
{
	RDFFormat rdfFormat = Rio.getParserFormatForFileName(resultFileURL);

	if (rdfFormat != null) {
		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;
	}
	else {
		throw new RuntimeException("Unable to determine file type of results file");
	}
}
 

/**
  * Read the expected graph query result from the specified resource
  * 
  * @param resultFile
  * @return
  * @throws Exception
  */
 private Set<Statement> readExpectedGraphQueryResult(String resultFile) throws Exception
 {
     final RDFFormat rdfFormat = Rio.getParserFormatForFileName(resultFile);
 
     if (rdfFormat != null) {
         final RDFParser parser = Rio.createParser(rdfFormat);
         parser.setDatatypeHandling(DatatypeHandling.IGNORE);
         parser.setPreserveBNodeIDs(true);
         parser.setValueFactory(ValueFactoryImpl.getInstance());
 
         final Set<Statement> result = new LinkedHashSet<Statement>();
         parser.setRDFHandler(new StatementCollector(result));
 
final InputStream in = TestFederatedQuery.class
		.getResourceAsStream(TEST_RESOURCE_PATH + resultFile);
         try {
             parser.parse(in, null);     // TODO check
         }
         finally {
             in.close();
         }
 
         return result;
     }
     else {
         throw new RuntimeException("Unable to determine file type of results file");
     }
 }
 

/**
 * test get Statemetns.
 * @throws Exception The test would fails if Exception occurs
 */
@Test
public void testGetStatements() throws Exception {
	//insert some statments first
	for (final String tripleAsString : _data) {
		final Statement triple = parseNX(tripleAsString).iterator().next();
		TRIPLE_STORE.addData(triple);
	}
	//test get the statements
	String uri = BASE_URI + Protocol.REPOSITORIES + "/" + REPO_ID + "/" + Protocol.STATEMENTS;
	File tmp = WebTestUtils.tmpFile();
	final ServletOutputStream servletOutputStream = new StubServletOutputStream(tmp);
	final HttpServletRequest request = mockHttpRequest(uri, METHOD_GET);
	when(request.getParameter(Protocol.SUBJECT_PARAM_NAME)).thenReturn(DEVICE);
	when(request.getParameter(Protocol.ACCEPT_PARAM_NAME)).thenReturn(MIMETYPE_RDF_XML);
	when(request.getCharacterEncoding()).thenReturn(UTF_8);
	final HttpServletResponse response = mock(HttpServletResponse.class);
	when(response.getOutputStream()).thenReturn(servletOutputStream);

	GetMethod method = new GetMethod(uri);
	RDFFormat format = RDFFormat.RDFXML;
	RDFParser parser = Rio.createParser(format, valueFactory);
	parser.setParserConfig(parser.getParserConfig());
	StatementCollector collector = new StatementCollector();
	parser.setRDFHandler(collector);
	_classUnderTest.service(request, response);

	parser.parse(new FileInputStream(tmp), method.getURI().getURI());
	assertTrue(!collector.getStatements().isEmpty());
	verify(response).setStatus(HttpServletResponse.SC_OK);

	servletOutputStream.close();
}
 

/**
 * Parses the incoming RDF stream according with a given format.
 * 
 * @param stream
 *            the RDF (input) stream.
 * @param format
 *            the {@link RDFFormat} that will be used for parsing.
 * @return a {@link List} with collected statements.
 */
public static List<Statement> parseAsList(final InputStream stream, final RDFFormat format) {
	final List<Statement> statements = new ArrayList<Statement>();
	try {
		final RDFParser parser = Rio.createParser(format, VALUE_FACTORY);
		parser.setRDFHandler(new StatementCollector(statements));
		parser.parse(stream, "");
	} catch (final Exception exception) {
		LOGGER.error(MessageCatalog._00029_RDF_PARSE_FAILURE, exception);
	}
	return statements;
}
 

@Override
public void injectTriples(TripleSink sink) throws IOException {
	try {
		Collector collector = new Collector();
		RDFParser parser =Rio.createParser(this.format);
		parser.setRDFHandler(collector);
		parser.parse(new StringReader(this.content), this.base);
		SesameModelParser tripleParser=new SesameModelParser(collector.getNamespaces());
		for(Statement st:collector.getStatements()) {
			sink.addTriple(tripleParser.parseStatement(st));
		}
	} catch (OpenRDFException e) {
		throw new IOException(e);
	}
}
 

/**
 * 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;

}
 

public Set<Statement> readExpectedGraphQueryResult() throws Exception {

            if (expectedGraphQueryResult != null)
                return expectedGraphQueryResult;
            
            final RDFFormat rdfFormat = Rio
                    .getParserFormatForFileName(resultFileURL);

            if (rdfFormat != null) {

                final RDFParser parser = Rio.createParser(rdfFormat);
                parser.setDatatypeHandling(DatatypeHandling.IGNORE);
                parser.setPreserveBNodeIDs(true);
                parser.setValueFactory(store.getValueFactory());

                final Set<Statement> result = new LinkedHashSet<Statement>();
                
                parser.setRDFHandler(new StatementCollector(result));

                final InputStream in = getResourceAsStream(resultFileURL);
                
                try {
                
                    parser.parse(in, resultFileURL);
                    
                } finally {
                    
                    in.close();
                    
                }
                
                expectedGraphQueryResult = result;

                return result;
                
            } else {

                throw new RuntimeException(
                        "Unable to determine file type of results file: "
                                + resultFileURL);

            }
            
        }