urinode.java

这是外国一个开源推理机

			}
		}
		else {
			throw new GraphException("source not writable");
		}
	}
	
	public StatementIterator getDirectSubClassStatements() {
		if (_directSubClassStatements == null) {
			//ThreadLog.trace("Determinining directSubClass cache for " + this.toString());
			_directSubClassStatements = new StatementList();
			
			RdfSchemaRepository repository = (RdfSchemaRepository)_source;
	
			StatementIterator subClassOfIter = repository.getSubClassOf(null, this);
			List subClasses = new ArrayList();
			
			while (subClassOfIter.hasNext()) {
				Statement st = subClassOfIter.next();
				// skip equivalent classes.
				if (!repository.isSubClassOf(this, st.getSubject())) { 
					subClasses.add(st.getSubject());
				}
			}
			subClassOfIter.close();
			
			subClassOfIter = repository.getSubClassOf(null, this);
			while (subClassOfIter.hasNext()) {
				
				Statement stat = subClassOfIter.next();
				
				if (_isDirectSubClassStat(stat, subClasses)) {
					//ThreadLog.trace("found direct subClass statement: " + stat.toString());
					_directSubClassStatements.add(stat);
				}
			}
		}
		//ThreadLog.trace("Returning directSubClass cache for " + this.toString());
		return new MemStatementIterator(_directSubClassStatements);
	}
	
	public boolean isDirectSubClass(Resource aClass) {
		boolean result = false;
		
		StatementIterator subClasses = getDirectSubClassStatements();
		
		while (subClasses.hasNext()) {
			Statement st = subClasses.next();
			if (st.getSubject().equals(aClass)) {
				result = true;
				break;
			}
		}
		subClasses.close();
		
		return result;
	}
	
	private boolean _isDirectSubClassStat(Statement stat, List subClasses) {
		RdfSchemaRepository repository = (RdfSchemaRepository)_source;
		
		//ThreadLog.trace("Determining if " + stat.toString() + " is a direct subclass of " + this.toString());
		ResourceNode subNode = (ResourceNode)stat.getSubject();
		
		if (subNode == this) {
			// a class is never a direct subclass of itself.
			//ThreadLog.trace("not a direct subclass");
			return false;
		}

		if (repository.isSubClassOf(this, subNode)) {
			// cycle in the class hierarchy, classes are equivalent
			//ThreadLog.trace("not a direct subclass");
			return false;
		}

		// 'subClass' is a direct subclass of 'superClass' when the
		// set of superclasses of 'subClass' and the set of subclasses
		// of 'superClass' are disjoint (when ignoring 'subClass' and
		// 'superClass' in the sets).
		boolean isDirect = true;

		// Check whether one of the superclasses of 'subClass' is
		// present in 'subClasses', again ignoring 'subClass'
		// and 'superClass'
		StatementIterator supsOfSubClassIter = repository.getSubClassOf(subNode, null);
		while (supsOfSubClassIter.hasNext()) {
			Statement st = supsOfSubClassIter.next();

			if (st.getObject() instanceof Resource) {
				Resource r = (Resource)st.getObject();

				if (r != subNode && r != this &&
					subClasses.contains(r) &&
					!repository.isSubClassOf(r, subNode)) // ignore equivalent classes
				{
					isDirect = false;
					break;
				}
			}
		}
		supsOfSubClassIter.close();

		//ThreadLog.trace("Returning direct subClass: " + isDirect);
		return isDirect;
	}
	
	public StatementIterator getDirectTypeStatements() {
		if (_directTypeStatements == null) {
			//ThreadLog.trace("determining direct types cache for " + this.toString());
			RdfSchemaRepository repository = (RdfSchemaRepository)_source;
			
			_directTypeStatements = new StatementList();
			
			StatementList typeStatements = new StatementList();
			List classes = new ArrayList();

			//ThreadLog.trace("Getting all type statements...");
			StatementIterator iter = repository.getStatements(this, repository.RDF_TYPE_NODE, null, false);
			while (iter.hasNext()) {
				Statement st = iter.next();
				if (st.getPredicate().equals(repository.RDF_TYPE_NODE)){
					typeStatements.add(st);
					classes.add(st.getObject());
				}
			}
			iter.close();
			//ThreadLog.trace("type statements retrieved: " + classes.size());
			
			StatementIterator typeIter = new MemStatementIterator(typeStatements);
			
			Statement rdfsResourceStatement = null;
			while (typeIter.hasNext()) {
				Statement typeSt = typeIter.next();
				
				ResourceNode type = (ResourceNode)typeSt.getObject();
				if (type.equals(repository.RDFS_RESOURCE_NODE)) {
					// skip the top class: it is only a direct type if no other direct types
					// can be found.
					rdfsResourceStatement = typeSt;
					continue;
				}
				
				StatementIterator subClassIter = type.getDirectSubClassStatements();
				
				boolean directType = true;
				while (directType && subClassIter.hasNext()) {
					Resource aClass = subClassIter.next().getSubject();
					
					if (classes.contains(aClass) ) {
						directType = false;
					}
				}
				
				if (directType) {
					//ThreadLog.trace("found a direct type statement: " + typeSt.toString());
					_directTypeStatements.add(typeSt);
				}
			}
			typeIter.close();
			
			// if no direct type relations were found,the only direct type is the top class, rdfs:Resource
			if (_directTypeStatements.size() == 0) {
				_directTypeStatements.add(rdfsResourceStatement);
			}
		}
		
		
		//ThreadLog.trace("Returning direct type cache for " + this.toString());
		return new MemStatementIterator(_directTypeStatements);
	}
	
	public boolean isDirectType(Resource aClass) {
		
		boolean result = false;
		
		StatementIterator directTypes = getDirectTypeStatements();
		
		while (directTypes.hasNext()) {
			Statement st = directTypes.next();
			if (st.getObject().equals(aClass)) {
				result = true;
				break;
			}
		}
		directTypes.close();
		return result;
	}

	public StatementIterator getDirectSubPropertyStatements() {
		if (_directSubPropertyStatements == null) {
			//ThreadLog.trace("Determinining directSubProp cache for " + this.toString());
			_directSubPropertyStatements = new StatementList();
			
			RdfSchemaRepository repository = (RdfSchemaRepository)_source;
	
			StatementIterator subPropertyOfIter = repository.getSubPropertyOf(null, this);
			List subProps = new ArrayList();
			
			while (subPropertyOfIter.hasNext()) {
				Statement st = subPropertyOfIter.next();
				//skip equivalent properties
				if (!repository.isSubPropertyOf(this, st.getSubject())) { 
					subProps.add(st.getSubject());
				}
			}
			subPropertyOfIter.close();
			
			subPropertyOfIter = repository.getSubPropertyOf(null, this);
			while (subPropertyOfIter.hasNext()) {
				
				Statement stat = subPropertyOfIter.next();
				
				if (_isDirectSubPropertyStat(stat, subProps)) {
					//ThreadLog.trace("found direct subProp statement: " + stat.toString());
					_directSubPropertyStatements.add(stat);
				}
			}
		}
		//ThreadLog.trace("Returning directSubProp cache for " + this.toString());
		return new MemStatementIterator(_directSubPropertyStatements);
	}
	
	public boolean isDirectSubProperty(Resource aProperty) {
		boolean result = false;
		
		StatementIterator subProps = getDirectSubPropertyStatements();
		
		while (subProps.hasNext()) {
			Statement st = subProps.next();
			if (st.getSubject().equals(aProperty)) {
				result = true;
				break;
			}
		}
		subProps.close();
		
		return result;
	}
	
	private boolean _isDirectSubPropertyStat(Statement stat, List subProps) {
		RdfSchemaRepository repository = (RdfSchemaRepository)_source;
		
		//ThreadLog.trace("Determining if " + stat.toString() + " is a direct subprop of " + this.toString());
		ResourceNode subNode = (ResourceNode)stat.getSubject();
		
		if (subNode == this) {
			// a prop is never a direct subprop of itself.
			//ThreadLog.trace("not a direct subprop");
			return false;
		}

		if (repository.isSubPropertyOf(this, subNode)) {
			// cycle in the property hierarchy, props are equivalent
			//ThreadLog.trace("not a direct subprop");
			return false;
		}

		// 'subProp' is a direct subclass of 'superProp' when the
		// set of superproperties of 'subProp' and the set of subproperties
		// of 'superProp' are disjoint (when ignorning 'subProp' and
		// 'superProp' in the sets).
		boolean isDirect = true;

		// Check whether one of the superproperties of 'subProp' is
		// present in 'subProps', again ignoring 'subProp'
		// and 'superProp'
		StatementIterator supsOfSubPropIter = repository.getSubPropertyOf(subNode, null);
		while (supsOfSubPropIter.hasNext()) {
			Statement st = supsOfSubPropIter.next();

			if (st.getObject() instanceof Resource) {
				Resource r = (Resource)st.getObject();

				if (r != subNode && r != this &&
					subProps.contains(r) &&
					!repository.isSubPropertyOf(r, subNode)) // ignore equivalent properties
				{
					isDirect = false;
					break;
				}
			}
		}
		supsOfSubPropIter.close();

		//ThreadLog.trace("Returning direct subProperty: " + isDirect);
		return isDirect;
	}

	public void clearCache() {
		_directSubClassStatements = null;
		_directTypeStatements = null;
		_directSubPropertyStatements = null;
	}
}