rdfsource.java

这是外国一个开源推理机

		if (subjNode == null) {
			subjNode = _createResourceNode(subj);
			newNodeCreated = true;
		}

		URINode predNode = _getURINode(pred);
		if (predNode == null) {
			predNode = _createURINode(pred);
			newNodeCreated = true;
		}

		ValueNode objNode = _getValueNode(obj);
		if (objNode == null) {
			objNode = _createValueNode(obj);
			newNodeCreated = true;
		}

		if (!newNodeCreated) {
			// All nodes were already present in the graph. Possibly, the
			// statement is already present. Check this.
			StatementIterator statIter = getStatements(subjNode, predNode,
					objNode);
			if (statIter.hasNext()) {
				// statement is already present, don't add it again.
				MemStatement st = (MemStatement) statIter.next();
				statIter.close();
				return st;
			}
			statIter.close();
		}

		// This is a new statement, add it.

		MemStatement st = new MemStatement(subjNode, predNode, objNode);

		_statements.add(st);

		subjNode.addSubjectStatement(st);
		predNode.addPredicateStatement(st);
		objNode.addObjectStatement(st);

		return st;
	}

/*----------------------------------------------+
| Methods for acquiring and creating ValueNodes |
+----------------------------------------------*/

	/**
	 * Checks whether the supplied value is an instance of <tt>ValueNode</tt>
	 * and whether it has been created by this RdfSource.
	 **/
	protected boolean _isOwnValueNode(Value value) {
		return value instanceof ValueNode &&
			((ValueNode)value).getRdfSource() == this;
	}

	/**
	 * Returns a value that is equal to the supplied value but that is shared
	 * with other objects.
	 * 
	 * @param value A Value object.
	 * @return A shared ValueNode that is equal to v, or null if no such value
	 * exists.
	 */
	protected ValueNode _getValueNode(Value value) {
		if (value instanceof Resource) {
			return _getResourceNode( (Resource)value );
		}
		else if (value instanceof Literal) {
			return _getLiteralNode( (Literal)value );
		}
		else {
			throw new RuntimeException("value is not a Resource or Literal: " + value);
		}
	}

	/**
	 * See _getValueNode() for desription.
	 */
	protected ResourceNode _getResourceNode(Resource resource) {
		if (resource instanceof URI) {
			return _getURINode( (URI)resource);
		}
		else if (resource instanceof BNode) {
			return _getBNodeNode( (BNode)resource);
		}
		else {
			throw new RuntimeException("resource is not a URI or BNode");
		}
	}

	/**
	 * See _getValueNode() for desription.
	 */
	protected URINode _getURINode(URI uri) {
		if (_isOwnValueNode(uri)) {
			return (URINode)uri;
		}
		else {
			return (URINode)_uriNodesMap.get(uri);
		}
	}

	/**
	 * See _getValueNode() for desription.
	 */
	protected BNodeNode _getBNodeNode(BNode bNode) {
		if (_isOwnValueNode(bNode)) {
			return (BNodeNode)bNode;
		}
		else {
			return (BNodeNode)_bNodeNodesMap.get(bNode);
		}
	}

	/**
	 * See _getValueNode() for desription.
	 */
	protected LiteralNode _getLiteralNode(Literal literal) {
		if (_isOwnValueNode(literal)) {
			return (LiteralNode)literal;
		}
		else {
			return (LiteralNode)_literalNodesMap.get(literal);
		}
	}

	/**
	 * Creates a ValueNode for the supplied Value. The supplied value should not
	 * already have an associated ValueNode. The created ValueNode is returned.
	 * 
	 * @param value A Resource or Literal.
	 * @return The created ValueNode.
	 */
	protected ValueNode _createValueNode(Value value) {
		if (value instanceof Resource) {
			return _createResourceNode( (Resource)value );
		}
		else if (value instanceof Literal) {
			return _createLiteralNode( (Literal)value );
		}
		else {
			throw new RuntimeException("value is not a Resource or Literal");
		}
	}

	/**
	 * See _createValueNode() for description.
	 */
	protected ResourceNode _createResourceNode(Resource resource) {
		if (resource instanceof URI) {
			return _createURINode( (URI)resource );
		}
		else if (resource instanceof BNode) {
			return _createBNodeNode( (BNode)resource );
		}
		else {
			throw new RuntimeException("resource is not a URI or BNode");
		}
	}

	/**
	 * See _createValueNode() for description.
	 */
	protected URINode _createURINode(URI uri) {
		// Namespace strings are relatively large objects and
		// are shared between uris
		String namespace = uri.getNamespace();
		Namespace n = (Namespace) _namespacesTable.get(namespace);

		if (n == null) {
			// New namespace, add it to the register.
			n = _registerNamespace(namespace, false);
		}
		else {
			// Use the shared namespace
			namespace = n.getName();
		}

		// Create a new URINode
		URINode uriNode = new URINode(this, namespace, uri.getLocalName());

		Object existingNode = _uriNodesMap.put(uriNode, uriNode);
		if (existingNode != null) {
			throw new SailInternalException("Created a duplicate URINode for uri " + uri);
		}

		return uriNode;
	}

	/**
	 * See _createValueNode() for description.
	 */
	protected BNodeNode _createBNodeNode(BNode bNode) {
		BNodeNode bNodeNode = new BNodeNode(this, bNode.getID());

		Object existingNode = _bNodeNodesMap.put(bNodeNode, bNodeNode);
		if (existingNode != null) {
			throw new SailInternalException("Created a duplicate BNodeNode for bNode " + bNode);
		}

		return bNodeNode;
	}

	/**
	 * See _createValueNode() for description.
	 */
	protected LiteralNode _createLiteralNode(Literal literal) {
		LiteralNode literalNode = null;

		if (literal.getDatatype() != null) {
			literalNode = new LiteralNode(this, literal.getLabel(), literal.getDatatype());
		}
		else if (literal.getLanguage() != null) {
			literalNode = new LiteralNode(this, literal.getLabel(), literal.getLanguage());
		}
		else {
			literalNode = new LiteralNode(this, literal.getLabel());
		}

		Object existingNode = _literalNodesMap.put(literalNode, literalNode);
		if (existingNode != null) {
			throw new SailInternalException("Created a duplicate LiteralNode for literal " + literal);
		}

		return literalNode;
	}

	protected Namespace _registerNamespace(String name, boolean export) {
		return _registerNamespace("ns" + _nextNsPrefixId++, name, export);
	}

	protected Namespace _registerNamespace(String prefix, String name, boolean export) {
		Namespace namespace = new Namespace(prefix, name, export);
		_namespacesTable.put(name, namespace);
		_namespacesList.add(namespace);
		return namespace;
	}

	protected void _updateExportedNamespaces() {
		Set namespacesSet = new HashSet();

		// Gather the namespaces used in predicates
		for (int i = 0; i < _statements.size(); i++) {
			Statement st = (Statement) _statements.get(i);
			URI pred = st.getPredicate();
			namespacesSet.add(pred.getNamespace());
		}

		// Update the export flag in all namespaces
		for (int i = 0; i < _namespacesList.size(); i++) {
			Namespace namespace = (Namespace) _namespacesList.get(i);
			namespace.setExported(namespacesSet.contains(namespace.getName()));
		}

		_exportStatusUpToDate = true;
	}

/*--------------------------+
| Reading from files        |
+--------------------------*/

	protected void _readFromFile()
		throws SailInitializationException
	{
		// Don't try to read files of length 0: with compression enabled this
		// will result in an IOException being thrown (gzip-files always contain
		// at least a header), and the file doesn't contain any data anyway.
		if (_file.length() == 0L) {
			return;
		}

		try {
			Parser parser = null;
			if (_dataFormat == RDFFormat.RDFXML) {
				parser = new RdfXmlParser(this);
			}
			else if (_dataFormat == RDFFormat.NTRIPLES) {
				parser = new NTriplesParser(this);
			}
			else if (_dataFormat == RDFFormat.TURTLE) {
				parser = new TurtleParser(this);
			}
			else {
				throw new SailInitializationException("Illegal value for data format: " + _dataFormat.toString());
			}

			parser.setNamespaceListener(new NamespaceListener());
			parser.setStatementHandler(new StatementHandler());

			InputStream in = new FileInputStream(_file);
			try {
				if (_compressFile) {
					in = new GZIPInputStream(in, 4096);
				}
				in = new BufferedInputStream(in, 4096);

				parser.parse(in, "file://" + _file.getPath());
			}
			finally {
				in.close();
			}
		}
		catch (ParseException e) {
			throw new SailInitializationException("Parse error on line " + e.getLineNumber(), e);
		}
		catch (IOException e) {
			throw new SailInitializationException("I/O error on reading file " + _file, e);
		}
		catch (StatementHandlerException e) {
			throw new RuntimeException("Unexpected StatementHandlerException: " + e.getMessage());
		}
	}

	class NamespaceListener implements org.openrdf.rio.NamespaceListener {
		public void handleNamespace(String prefix, String uri) {
			if (!_namespacesTable.containsKey(uri)) {
				_registerNamespace(prefix, uri, true);
			}
		}
	}

	class StatementHandler implements org.openrdf.rio.StatementHandler {
		public void handleStatement(Resource subject, URI predicate, Value object) {
			_addStatement(subject, predicate, object);
		}
	}

	// Implements ValueFactory#createURI(String)
	public URI createURI(String uri) {
		URI tempURI = new URIImpl(uri);
		URINode node = _getURINode(tempURI);
		if (node == null) {
			node = _createURINode(tempURI);
		}
		return node;
	}
	
	public URI createURI(String namespace, String localName) {
		URI tempURI = new URIImpl(namespace, localName);
		URINode node = _getURINode(tempURI);
		if (node == null) {
			node = _createURINode(tempURI);
		}
		return node;
	}

	// Implements ValueFactory#createBNode()
	public BNode createBNode() {
		if (_nextBNodeID == Integer.MAX_VALUE) {
			// Start with a new bnode prefix
			_updateBNodePrefix();
		}

		return createBNode(_bnodePrefix + _nextBNodeID++);
	}
	
	// Implements ValueFactory#createBNode(String)
	public BNode createBNode(String nodeId) {
		BNode tempBNode = new BNodeImpl(nodeId);
		BNodeNode node = _getBNodeNode(tempBNode);
		if (node == null) {
			node = _createBNodeNode(tempBNode);
		}
		return node;
	}

	// Implements ValueFactory#createLiteral(String)
	public Literal createLiteral(String value) {
		Literal tempLiteral = new LiteralImpl(value);
		LiteralNode node = _getLiteralNode(tempLiteral);
		if (node == null) {
			node = _createLiteralNode(tempLiteral);
		}
		return node;
	}

	// Implements ValueFactory#createLiteral(String, String)
	public Literal createLiteral(String value, String language) {
		Literal tempLiteral = new LiteralImpl(value, language);
		LiteralNode node = _getLiteralNode(tempLiteral);
		if (node == null) {
			node = _createLiteralNode(tempLiteral);
		}
		return node;
	}

	// Implements ValueFactory#createLiteral(String, URI)
	public Literal createLiteral(String value, URI datatype) {
		Literal tempLiteral = new LiteralImpl(value, datatype);
		LiteralNode node = _getLiteralNode(tempLiteral);
		if (node == null) {
			node = _createLiteralNode(tempLiteral);
		}
		return node;
	}

	// Implements ValueFactory#createStatement(Resource, URI, Value)
	public Statement createStatement(Resource subject, URI predicate, Value object) {
		Statement result = null;

		StatementIterator stIter = getStatements(subject, predicate, object);
		if (stIter.hasNext()) {
			result = stIter.next();
		}
		stIter.close();

		if (result == null) {
			result = new MemStatement(subject, predicate, object);
		}

		return result;
	}
}