rdfschemarepository.java

这是外国一个开源推理机

		boolean result = stIter.hasNext();
		stIter.close();
		return result;
	}

	// inherit javadoc
	public StatementIterator getSubPropertyOf(Resource subProperty, Resource superProperty) {
		return getStatements(subProperty, RDFS_SUBPROPERTYOF_NODE, superProperty);
	}

	// inherit javadoc
	public boolean isSubPropertyOf(Resource subProperty, Resource superProperty) {
		return hasStatement(subProperty, RDFS_SUBPROPERTYOF_NODE, superProperty);
	}

	// inherit javadoc
	public StatementIterator getDirectSubPropertyOf(Resource subProp, Resource superProp) {
		ResourceNode subPropNode = null;
		ResourceNode superPropNode = null;
		if (superProp != null && subProp != null) {
			superPropNode = _getResourceNode(superProp);
			if (superPropNode == null) {
				return new EmptyStatementIterator();
			}
			subPropNode = _getResourceNode(subProp);
			if (subPropNode == null) {
				return new EmptyStatementIterator();
			}
			StatementIterator iter = superPropNode.getDirectSubPropertyStatements();
			StatementList list = new StatementList();
			while (iter.hasNext()) {
				Statement st = iter.next();
				if (st.getSubject().equals(subProp)) {
					list.add(st);
					break;
				}
			}
			iter.close();
			return new MemStatementIterator(list);
		}
		if (superProp != null) {
			superPropNode = _getResourceNode(superProp);
			if (superPropNode == null) {
				return new EmptyStatementIterator();
			}
			if (subProp == null) { 
				return superPropNode.getDirectSubPropertyStatements();
			}
		}
		if (subProp != null) {
			subPropNode = _getResourceNode(subProp);
			if (subPropNode == null) {
				return new EmptyStatementIterator();
			}
			if (superProp == null) {
				StatementIterator superPropIter = getStatements(subProp, RDFS_SUBPROPERTYOF_NODE, null, false);
				StatementList directSuperProps = new StatementList();
				
				while (superPropIter.hasNext()) {
					Statement st = superPropIter.next();
					superPropNode = (ResourceNode)st.getObject();
					
					if (superPropNode.isDirectSubProperty(subProp)) {
						directSuperProps.add(st);
					}
				}
				superPropIter.close();
				
				return new MemStatementIterator(directSuperProps);
			}
		}

		// both arguments null: retrieve all direct subClass relations in the graph.
		StatementIterator subPropIter = new MemStatementIterator(RDFS_SUBPROPERTYOF_NODE.getPredicateStatementList());
		StatementList directSubPropStatements = new StatementList();
		
		while (subPropIter.hasNext()) {
			Statement st = subPropIter.next();
	
			ResourceNode subject = (ResourceNode)st.getSubject();
			
			StatementIterator iter = subject.getDirectSubPropertyStatements();
			while (iter.hasNext()) {
				directSubPropStatements.add(iter.next());
			}
			iter.close();
		}
		subPropIter.close();
		
		return new MemStatementIterator(directSubPropStatements);
	}

	// inherit javadoc
	public boolean isDirectSubPropertyOf(Resource subProperty, Resource superProperty) {
		StatementIterator stIter = getDirectSubPropertyOf(subProperty, superProperty);
		boolean result = stIter.hasNext();
		stIter.close();
		return result;
	}

	// inherit javadoc
	public StatementIterator getDomain(Resource prop, Resource domain) {
		return getStatements(prop, RDFS_DOMAIN_NODE, domain);
	}

	// inherit javadoc
	public StatementIterator getRange(Resource prop, Resource range) {
		return getStatements(prop, RDFS_RANGE_NODE, range);
	}

	// inherit javadoc
	public StatementIterator getType(Resource anInstance, Resource aClass) {
		return getStatements(anInstance, RDF_TYPE_NODE, aClass);
	}

	// inherit javadoc
	public boolean isType(Resource anInstance, Resource aClass) {
		return hasStatement(anInstance, RDF_TYPE_NODE, aClass);
	}

	public StatementIterator getDirectType(Resource anInstance, Resource aClass) {
		ResourceNode instanceNode = null;
		ResourceNode classNode = null;
		if (anInstance != null && aClass != null) {
			classNode = _getResourceNode(aClass);
			if (classNode == null) {
				return new EmptyStatementIterator();
			}
			instanceNode = _getResourceNode(anInstance);
			if (instanceNode == null) {
				return new EmptyStatementIterator();
			}
			StatementIterator iter = instanceNode.getDirectTypeStatements();
			StatementList list = new StatementList();
			while (iter.hasNext()) {
				Statement st = iter.next();
				if (st.getObject().equals(classNode)) {
					list.add(st);
					break;
				}
			}
			iter.close();
			return new MemStatementIterator(list);
		}
		if (anInstance != null) {
			instanceNode = _getResourceNode(anInstance);
			if (instanceNode == null) {
				return new EmptyStatementIterator();
			}
			if (aClass == null) {
				return instanceNode.getDirectTypeStatements();
			}
		}
		if (aClass != null) {
			classNode = _getResourceNode(aClass);
			if (classNode == null) {
				return new EmptyStatementIterator();
			}
			if (anInstance == null) {
				StatementList directInstances = new StatementList();
				StatementIterator instanceIter = getStatements(null, RDF_TYPE_NODE, classNode, false);
				
				while (instanceIter.hasNext()) {
					Statement st = instanceIter.next();
					if (((ResourceNode)st.getSubject()).isDirectType(aClass)) {
						directInstances.add(st);
					}
				}
				instanceIter.close();
				return new MemStatementIterator(directInstances);
			}
		}

		// both arguments null: retrieve all direct type relations in the graph.
		StatementIterator typeIter = new MemStatementIterator(RDF_TYPE_NODE.getPredicateStatementList());
		StatementList directTypeStatements = new StatementList();
		
		while (typeIter.hasNext()) {
			Statement st = typeIter.next();
			ResourceNode subject = (ResourceNode)st.getSubject();
			
			StatementIterator iter = subject.getDirectTypeStatements();
			
			while (iter.hasNext()) {
				directTypeStatements.add(iter.next());
			}
			iter.close();
		}
		typeIter.close();
		
		return new MemStatementIterator(directTypeStatements);
	}

	// inherit javadoc
	public boolean isDirectType(Resource anInstance, Resource aClass) {
		StatementIterator stIter = getDirectType(anInstance, aClass);
		boolean result = stIter.hasNext();
		stIter.close();
		return result;
	}

	public LiteralIterator getLiterals(String label, String language, URI datatype) {
		return new MemLiteralIterator(
				_literalNodesMap.values(), label, language, datatype);
	}

	// inherit javadoc
	public void commitTransaction() {

		_clearAllCaches();
		
		if (_statementsRemoved) {
			_removeInferredStatements();

			// Mark all remaining (=explicit) statements as new
			_inferencer.notifyNewStatements(_statements);

			// Add axioms and apply inferencing
			_inferencer.initialize();
		}
		else {
			_inferencer.doInferencing();
		}

		_statementsRemoved = false;

		super.commitTransaction();
	}

	// overrides RdfRepository.addStatement()
	public void addStatement(Resource subj, URI pred, Value obj)
		throws SailUpdateException
	{
		if (!transactionStarted()) {
			throw new SailUpdateException("no transaction started.");
		}

		Statement st = _addStatement(subj, pred, obj);

		_inferencer.notifyNewStatement(st);
		_sailChangedEvent.setStatementsAdded(true);
	}

	// overrides RdfRepository.removeStatements()
	public int removeStatements(Resource subj, URI pred, Value obj)
		throws SailUpdateException
	{
		if (!transactionStarted()) {
			throw new SailUpdateException("no transaction started.");
		}

		int nrOfStatements = super.removeStatements(subj, pred, obj);

		if (nrOfStatements > 0) {
			_statementsRemoved = true;
			_sailChangedEvent.setStatementsRemoved(true);
		}

		return nrOfStatements;
	}

	/**
	 * Overrides <tt>RdfRepository._matchesForRemoval(...)</tt> such that it
	 * only matches explicit statements. Inferred statements cannot be removed
	 * by hand, removal of these statements are handled by the inferencer.
	 *
	 * @see RdfRepository#_matchesForRemoval
	 **/
	protected boolean _matchesForRemoval(Statement st, Resource subj, URI pred, Value obj) {
		return ((MemStatement)st).isExplicit() &&
				super._matchesForRemoval(st, subj, pred, obj);
	}


	public void clearRepository()
		throws SailUpdateException
	{
		super.clearRepository();

		_initRdfPrimitives();

		// Add axioms and apply inferencing
		_inferencer.initialize();
	}

	// Method called by RdfMTInferencer
	protected MemStatement _getMemStatement(Resource subj, URI pred, Value obj) {
		MemStatement result = null;

		StatementIterator iter = getStatements(subj, pred, obj, false);
		if (iter.hasNext()) {
			result = (MemStatement)iter.next();
		}
		iter.close();

		return result;
	}

	// overrides RdfSource._addStatement
	protected MemStatement _addStatement(Resource subj, URI pred, Value obj) {
		MemStatement st = super._addStatement(subj, pred, obj);

		// An implicit statement could already have been present, make
		// sure the added statement is explicit.
		st.setExplicit(true);

		return st;
	}

	// override RdfRepository._exportData(RdfDocumentWriter): only write explicit statements.
	protected void _exportData(RdfDocumentWriter docWriter)
		throws IOException
	{
		RdfExport rdfExport = new RdfExport();
		rdfExport.exportRdf(this, docWriter, true, true, true, false);
	}

/*----------------+
| private methods |
+----------------*/

	/**
	 * Removes all inferred statements.
	 **/
	private void _removeInferredStatements() {
		int size = _statements.size();
		for (int i = size - 1; i >= 0; --i) {
			MemStatement st = (MemStatement)_statements.get(i);

			if (!st.isExplicit()) {
				// Inferred statement, remove all references to it from ValueNodes.
				ResourceNode rn = (ResourceNode)st.getSubject();
				rn.removeSubjectStatement(st);

				URINode un = (URINode)st.getPredicate();
				un.removePredicateStatement(st);

				ValueNode vn = (ValueNode)st.getObject();
				vn.removeObjectStatement(st);

				_statements.remove(i);
			}
		}
	}


	private void _clearAllCaches() {
		
		// a single sweep over all subjects of type relations is enough: if something is a 
		// subclass or subproperty, it is by definition present as subject of a type relation.
		StatementIterator allTypeRelations = new MemStatementIterator(RDF_TYPE_NODE.getPredicateStatementList());
		while (allTypeRelations.hasNext()) {
			Statement st = allTypeRelations.next();
			((ResourceNode)st.getSubject()).clearCache();
		}
		allTypeRelations.close();

		/*
		StatementIterator allSubClassRelations = new MemStatementIterator(RDFS_SUBCLASSOF_NODE.getPredicateStatementList());
		
		while (allSubClassRelations.hasNext()) {
			Statement st = allSubClassRelations.next();
			((ResourceNode)st.getSubject()).clearCache();
		}
		allSubClassRelations.close();
		
		StatementIterator allSubPropRelations = new MemStatementIterator(RDFS_SUBPROPERTYOF_NODE.getPredicateStatementList());
		while (allSubPropRelations.hasNext()) {
			Statement st = allSubPropRelations.next();
			((ResourceNode)st.getSubject()).clearCache();
		}
		allSubPropRelations.close();
		*/		
	}
}