sesameupload.java

这是外国一个开源推理机

		return statementCount;
	}

	// Returns the number of statements found in the data.
	private int _verifyData(Reader reader, String baseURL, RDFFormat dataFormat)
		throws UpdateException, IOException
	{
		_report.status("Checking data for errors", -1, -1);
		ThreadLog.trace("Checking data for errors");

		// The RDF Parser
		Parser rdfParser = _createParser(dataFormat, baseURL, new ValueFactoryImpl());
		rdfParser.setVerifyData(true);
		rdfParser.setStopAtFirstError(false);
		rdfParser.setDatatypeHandling(Parser.DT_VERIFY);

		// The StatementHandler and ErrorListener
		ErrorHandler errorHandler = new ErrorHandler();
		rdfParser.setStatementHandler(errorHandler);
		rdfParser.setParseErrorListener(errorHandler);

		try {
			rdfParser.parse(reader, baseURL);
		}
		catch (IOException e) {
			ThreadLog.warning("unable to verify data", e);
			throw new UpdateException(e);
		}
		catch (ParseException e) {
			throw new UpdateException(e);
		}
		catch (StatementHandlerException e) {
			throw new UpdateException(e);
		}

		int errorCount = errorHandler.getErrorCount();
		int statementCount = errorHandler.getStatementCount();

		// Check number of errors
		if (errorCount > 0) {
			throw new UpdateException(errorCount + " errors found, please fix these first");
		}

		return statementCount;
	}

	private int _processStatements(
		InputStream inputStream, String baseURL, RDFFormat dataFormat)
		throws UpdateException, IOException
	{
		_report.status("Processing statements from data", -1, -1);
		ThreadLog.trace("Processing statements");

		// StatusReporter will report progress every STATUS_INTERVAL millisec.
		StatusReporter statusReporter = new StatusReporter(STATUS_INTERVAL, _report);

		_rdfRepository.startTransaction();
		statusReporter.start();

		// The RDF Parser
		Parser rdfParser = _createParser(dataFormat, baseURL, _rdfRepository.getValueFactory());
		rdfParser.setVerifyData(false);
		rdfParser.setStopAtFirstError(false);
		rdfParser.setDatatypeHandling(Parser.DT_VERIFY);

		// The StatementHandler
		StatementHandler statHandler = new StatementHandler(statusReporter);
		rdfParser.setStatementHandler(statHandler);

		// The NamespaceListener
		NamespaceListener nsListener = new NamespaceListener();
		rdfParser.setNamespaceListener(nsListener);

		try {
			rdfParser.parse(inputStream, baseURL);

			_report.status("Updating extracted namespace prefixes", -1, -1);
			ThreadLog.trace("Updating extracted namespace prefixes");

			Map namespaces = nsListener.getNamespaceMap();

			Iterator prefixes = namespaces.keySet().iterator();
			while (prefixes.hasNext()) {
				String prefix = (String)prefixes.next();
				String namespace = (String)namespaces.get(prefix);
				try {
					_rdfRepository.changeNamespacePrefix(namespace, prefix);
				}
				catch (SailUpdateException e) {
					_report.warning("Unable to set namespace prefix '" + prefix +
							"' for namespace '" + namespace + "': " + e.getMessage(), -1, -1, null);
				}
			}
		}
		catch (IOException e) {
			ThreadLog.warning("Unable to process data", e);
			throw new UpdateException(e);
		}
		catch (ParseException e) {
			ThreadLog.warning("Parse error", e);
			throw new UpdateException(e);
		}
		catch (StatementHandlerException e) {
			ThreadLog.warning("Statement handler exception", e);
			throw new UpdateException(e);
		}
		catch (OutOfMemoryError e) {
			ThreadLog.warning("Out of memory");
			_report.error("Out of memory", -1, -1, null);
			throw e;
		}
		finally {
			statusReporter.stopRunning();

			_report.status("Committing transaction...", -1, -1);
			ThreadLog.trace("Committing transaction");
			try {
				_rdfRepository.commitTransaction();
			}
			catch (SailInternalException e) {
				ThreadLog.error("Internal Sail error", e);
				_report.status(e.getMessage(), -1, -1);
			}
		}
		return statusReporter.getStatementCount();
	}

	private int _processStatements(
		Reader reader, String baseURL, RDFFormat dataFormat)
		throws UpdateException, IOException
	{
		_report.status("Processing statements from data", -1, -1);
		ThreadLog.trace("Processing statements");

		// StatusReporter will report progress every STATUS_INTERVAL millisec.
		StatusReporter statusReporter = new StatusReporter(STATUS_INTERVAL, _report);

		_rdfRepository.startTransaction();
		statusReporter.start();

		// The RDF Parser
		Parser rdfParser = _createParser(dataFormat, baseURL, _rdfRepository.getValueFactory());
		rdfParser.setVerifyData(false);
		rdfParser.setStopAtFirstError(false);
		rdfParser.setDatatypeHandling(Parser.DT_VERIFY);

		// The StatementHandler
		StatementHandler statHandler = new StatementHandler(statusReporter);
		rdfParser.setStatementHandler(statHandler);

		// The NamespaceListener
		NamespaceListener nsListener = new NamespaceListener();
		rdfParser.setNamespaceListener(nsListener);

		try {
			rdfParser.parse(reader, baseURL);

			_report.status("Updating extracted namespace prefixes", -1, -1);
			ThreadLog.trace("Updating extracted namespace prefixes");

			Map namespaces = nsListener.getNamespaceMap();

			Iterator prefixes = namespaces.keySet().iterator();
			while (prefixes.hasNext()) {
				String prefix = (String)prefixes.next();
				String namespace = (String)namespaces.get(prefix);
				try {
					_rdfRepository.changeNamespacePrefix(namespace, prefix);
				}
				catch (SailUpdateException e) {
					_report.warning("Unable to set namespace prefix '" + prefix +
							"' for namespace '" + namespace + "': " + e.getMessage(), -1, -1, null);
				}
			}
		}
		catch (IOException e) {
			ThreadLog.warning("Unable to process data", e);
			throw new UpdateException(e);
		}
		catch (ParseException e) {
			ThreadLog.warning("Parse error", e);
			throw new UpdateException(e);
		}
		catch (StatementHandlerException e) {
			ThreadLog.warning("Statement handler exception", e);
			throw new UpdateException(e);
		}
		catch (OutOfMemoryError e) {
			ThreadLog.warning("Out of memory");
			_report.error("Out of memory", -1, -1, null);
			throw e;
		}
		finally {
			statusReporter.stopRunning();

			_report.status("Committing transaction...", -1, -1);
			ThreadLog.trace("Committing transaction");
			try {
				_rdfRepository.commitTransaction();
			}
			catch (SailInternalException e) {
				ThreadLog.error("Internal Sail error", e);
				_report.status(e.getMessage(), -1, -1);
			}
		}
		return statusReporter.getStatementCount();
	}

	private Parser _createParser(RDFFormat dataFormat, String baseURL, ValueFactory valFactory) {
		Parser result = null;

		if (RDFFormat.RDFXML.equals(dataFormat)) {
			result = new RdfXmlParser(valFactory);
		}
		else if (RDFFormat.NTRIPLES.equals(dataFormat)) {
			result = new NTriplesParser(valFactory);
		}
		else if (RDFFormat.TURTLE.equals(dataFormat)) {
			result = new TurtleParser(valFactory);
		}
		else {
			throw new IllegalArgumentException("Illegal value for parameter 'dataFormat'");
		}

		return result;
	}

/*-----------------------------------------------+
| Inner class ErrorHandler                       |
+-----------------------------------------------*/

	class ErrorHandler
		implements org.openrdf.rio.StatementHandler, org.openrdf.rio.ParseErrorListener
	{
		private int _errorCount;
		private int _statementCount;
	
		public ErrorHandler() {
			_errorCount = 0;
			_statementCount = 0;
		}
	
		public int getErrorCount() {
			return _errorCount;
		}
	
		public void resetErrorCount() {
			_errorCount = 0;
		}
	
		public int getStatementCount() {
			return _statementCount;
		}
	
		public void resetStatementCount() {
			_statementCount = 0;
		}
	
	/*----------------------------------------------------------+
	| Methods from interface org.openrdf.rio.StatementHandler   |
	+----------------------------------------------------------*/
	
		public void handleStatement(Resource subject, URI predicate, Value object)
		{
			_statementCount++;
		}
	
	/*----------------------------------------------------------+
	| Methods from interface org.openrdf.rio.ParseErrorListener |
	+----------------------------------------------------------*/
	
		public void warning(String msg, int lineNo, int colNo) {
			_report.notification(msg, lineNo, colNo, null);
		}
	
		public void error(String msg, int lineNo, int colNo) {
			_report.warning(msg, lineNo, colNo, null);
			_errorCount++;
		}
	
		public void fatalError(String msg, int lineNo, int colNo) {
			_report.error(msg, lineNo, colNo, null);
			_errorCount++;
		}
	}

/*-----------------------------------------------+
| Inner class StatementHandler                   |
+-----------------------------------------------*/

	class StatementHandler
		implements org.openrdf.rio.StatementHandler
	{
		private StatusReporter _statusReporter;
	
		public StatementHandler(StatusReporter statusReporter) {
			_statusReporter = statusReporter;
		}
	
		public void handleStatement(Resource s, URI p, Value o) {
			try {
				_rdfRepository.addStatement(s, p, o);
	
				_statusReporter.statementAdded();
			}
			catch (SailUpdateException e) {
				_report.warning("Unable to add statement; " + e.getMessage().trim(),
						-1, -1, new StatementImpl(s, p, o));
			}
		}
	}

/*-----------------------------------------------+
| Inner class NamespaceListener                  |
+-----------------------------------------------*/

	static class NamespaceListener
		implements org.openrdf.rio.NamespaceListener
	{
		private Map _namespaceMap;

		public NamespaceListener() {
			_namespaceMap = new HashMap();
		}

		public void handleNamespace(String prefix, String uri) {
			if (prefix != null && prefix.trim().length() > 0 &&
				!_namespaceMap.containsKey(prefix)) // use the first declaraction
			{
				_namespaceMap.put(prefix, uri);
			}
		}

		public Map getNamespaceMap() {
			return _namespaceMap;
		}
	}
}