rdfsourcepool.java

这是外国一个开源推理机

			for (int j = 0; j < length; j++) {
				table[j][1] = new Reference();
			}
		}
		if (objectWild) {
			for (int j = 0; j < length; j++) {
				table[j][2] = new Reference();
			}
		}

		/* Get all statements. Check if pattern of subject, predicate and object
		 * does not exist.
		 */
		StatementIterator i = _getStatements(null, null, null, explicitOnly);

		while (i.hasNext() && currentSize < preferredSize) {
			Statement s = i.next();

			Resource statementSubject = s.getSubject();
			Resource statementPredicate = s.getPredicate();
			Value statementObject = s.getObject();
			boolean instanceOfResource = statementObject instanceof Resource;
			
			/* If subject, predicate or object are wildcards, anonymity is not
			 * relevant. If object type is an instance of rdfs:Literal, it cannot
			 * be anonymous.
			 */
			if ((subjectWild || !(statementSubject instanceof BNode)) && 
				(predicateWild || !(statementPredicate instanceof BNode)) &&
				(objectWild || !instanceOfResource || (instanceOfResource && !(((Resource)statementObject) instanceof BNode))) &&

				/* If object of statement is not of appropiate type, skip
				 * statement. If object is a wildcard, object type is not
				 * relevant.
				 */
				(objectWild || ((type && instanceOfResource) || (!type && !instanceOfResource)))) {

				referenceSubject.setReference(statementSubject);
				referencePredicate.setReference(statementPredicate);
				referenceObject.setReference(statementObject);

				// Check every combination.
				for (int j = 0; j < length && currentSize < preferredSize; j++) {
					Resource tableSubject = (Resource)table[j][0].getReference();
					URI tablePredicate = 
						(URI)table[j][1].getReference();

					Value tableObject = table[j][2].getReference();
						
					BMStatement statement = new BMStatement
						(tableSubject, tablePredicate, tableObject);

					// Skip check if statement already checked.
					if (!statements.contains(statement) && 
						!noStatements.contains(statement)) {

						// Check current statement.
						if (!_hasStatement(tableSubject, tablePredicate, 
										   tableObject, explicitOnly)) {

							noStatements.add(statement);
							currentSize++;
						}
						else {
							
							/* Add statement to List. If in List, it does not 
							 * have to be checked in the future.
							 */
							statements.add(statement);				
						}
					}
				}
			}
		}

		i.close();
		
		if (noStatements.size() == 0) {
			String warning = "Repository has no ";

			if (explicitOnly) {
				warning += "explicit ";
			}

			warning += "statements [";
			
			if (subjectWild) {
				warning += "null ";
			}
			else {
				warning += "foo ";
			}
			if (predicateWild) {
				warning += "null ";
			}
			else {
				warning += "bar ";
			}
			if (objectWild) {
				warning += "null] ";
			}
			else {
				warning += "bas] ";
			}

			warning += "where object is an instance of ";

			if (type) {
				warning += "rdfs:Resource ";
			}
			else {
				warning += "rdfs:Literal ";
			}

			warning += "which do not exist.";
			
			_warning(warning);
		}

		return new ArrayList(noStatements);
	}

	/* Creates a List of statements retrieved from repository with size is
	 * preferredSize. Ratio between statements where object is an instance of
	 * rdfs:Resource and rdfs:Literal is 1 on 1. Divides statements evenly over
	 * List. This means first statement is a statement where object is an
	 * instance of rdfs: Resource, second where object is an instance of
	 * rdfs:Literal, third where object is an instance of rdfs:Resource, etc.
	 */
	protected List _getStatements(int preferredSize, boolean explicitOnly) {

		/* preferredSize is divided by 2: one half where object of statements is
		 * an instance of rdfs:Resource, the other half rdfs:Literal.
		 */
		List resource =	_getStatements(preferredSize/2, explicitOnly, true);

		List literal =_getStatements(preferredSize/2, explicitOnly, false);

		int sizeResource = resource.size();
		int sizeLiteral = literal.size();

		/* Both Lists should be of equal size. If size of List A exceeds size
		 * of List B, size of List A is cut down to size of List B and vice
		 * versa. This is not the case if size of List B is equal to 0.
		 */
		if (sizeResource > sizeLiteral && sizeLiteral > 0) {
			resource = new ArrayList(resource.subList(0, sizeLiteral));
		}
		if (sizeLiteral > sizeResource && sizeResource > 0) {
			literal = new ArrayList(literal.subList(0, sizeResource));
		}

		ArrayList distributed = new ArrayList();
		Iterator i = resource.iterator();
		Iterator j = literal.iterator();

		// Divide distributed evenly.
		while (i.hasNext()) {
			distributed.add(i.next());
			distributed.add(j.next());
		}

		return _stripIds(distributed);
	}
	
	/* Creates a List of statements retrieved from repository with size is
	 * preferredSize. type is true indicates object of statements is an instance
	 * of rdfs:Resource, false rdfs:Literal. Statements in List are distributed
	 * evenly over repository. 
	 *
	 * Default approach...
	 */
	protected List _getStatements
		(int preferredSize, boolean explicitOnly, boolean type) {

		/* Iterate over all statements and count total number of statements of
		 * appropiate type.
		 */
		int statements = 0;
		StatementIterator i = _getStatements(null, null, null, explicitOnly);
		
		while (i.hasNext()) {
			Statement statement = i.next();
			
			Value object = statement.getObject();
			boolean instanceOfResource = object instanceof Resource;

			// If object is an instance of rdfs:Literal, it cannot be anonymous.
 			if (!(statement.getSubject() instanceof BNode) && 
				!(statement.getPredicate() instanceof BNode) &&
				(!instanceOfResource || (instanceOfResource && !(((Resource)object) instanceof BNode))) &&

				// If object is not of appropiate type, skip statement.
				((type && instanceOfResource) || (!type && !instanceOfResource))) {
				
				statements++;
			}
		}

		i.close();

		if (statements == 0) {
			String warning = "Repository has no ";

			if (explicitOnly) {
				warning += "explicit ";
			}

			warning += "statements where object is an instance of ";

			if (type) {
				warning += "rdfs:Resource.";
			}
			else {
				warning += "rdfs:Literal.";
			}

			_warning(warning);

			return new ArrayList();
		}

		// Compute interval on which statements are retrieved.
		double interval = (double)statements/preferredSize;

		/* Iterate over all statements and add statement to distributed if of
		 * appropiate type and on interval.
		 */		
		List distributed = new ArrayList();
		StatementIterator j = _getStatements(null, null, null, explicitOnly);

		/* If interval <= 1 then preferredSize is equal to or exceeds size and
		 * distributed is equal to all statements. Else statements are
		 * distributed evenly.
		 */
		if (interval <= 1) {
			while (j.hasNext()) {
				Statement statement = j.next();				
				Value object = statement.getObject();
				boolean instanceOfResource = object instanceof Resource;

				if (!(statement.getSubject() instanceof BNode) &&
					!(statement.getPredicate() instanceof BNode) &&
					(!instanceOfResource || (instanceOfResource && !(((Resource)object) instanceof BNode))) &&
					((type && instanceOfResource) || (!type && !instanceOfResource))) {
					
					distributed.add(new BMStatement(statement.getSubject(), 
													statement.getPredicate(), 
													statement.getObject()));
				}
			}
		}
		else {
			int position = 0;
			
			while (j.hasNext()) {
				Statement statement = j.next();
				Value object = statement.getObject();
				boolean instanceOfResource = object instanceof Resource;

				if (!(statement.getSubject() instanceof BNode) && 
					!(statement.getPredicate() instanceof BNode) &&
					(!instanceOfResource || (instanceOfResource && !(((Resource)object) instanceof BNode))) &&
					((type && instanceOfResource) || (!type && !instanceOfResource))) {

					position++;

					/* Computation of last position % interval should be zero and
					 * therefore last statement iterator returns should be added
					 * to distributed. Because of loss of precision, computation
					 * could fail and last statement is not added to distributed.
					 * To avoid this, another check is made, i.e. is current
					 * position equal to last position. 
					 */
					if (position % interval < 1 || position == statements) {

						// Position on interval.
						distributed.add(new BMStatement(statement.getSubject(),
														statement.getPredicate(),
														statement.getObject()));
					}
				}
			}
		}		

		return distributed;
	}
	
	protected boolean _hasStatement(Resource subject, URI predicate, 
									Value object, boolean explicitOnly) {

		return _rdfSource.hasStatement(subject, predicate, object);
	}

	protected StatementIterator 
		_getStatements(Resource subject, URI predicate, 
					   Value object, boolean explicitOnly) {

		return _rdfSource.getStatements(subject, predicate, object);
	}

	protected void _warning(String warning) {
		BMUtil.warning(warning);
	}

	protected List _stripIds(List list) {
		return BMUtil.stripIds(list);
	}

	protected List _distribute(Collection collection, int preferredSize) {
		return BMUtil.distribute(collection, preferredSize);
	}
}