/**
* Partition the members of an iterator into two lists, according to whether they are named or
* anonymous classes
*
* @param i An iterator to partition
* @param named A list of named classes
* @param anon A list of anonymous classes
*/
protected static void partitionByNamed(
Iterator<? extends OntClass> i, List<OntClass> named, List<OntClass> anon) {
while (i.hasNext()) {
OntClass c = i.next();
boolean ignore = false;
// duplicate check: we ignore this class if we've already got it
if (named.contains(c)) {
ignore = true;
}
// subsumption check: c must have only anon classes or Thing
// as super-classes to still qualify as a root class
Resource thing = c.getProfile().THING();
for (Iterator<OntClass> j = c.listSuperClasses(); !ignore && j.hasNext(); ) {
OntClass sup = j.next();
if (!((thing != null && sup.equals(thing)) || sup.isAnon() || sup.equals(c))) {
ignore = true;
}
}
if (!ignore) {
// place the class in the appropriate partition
(c.isAnon() ? anon : named).add(c);
}
}
}
/**
* Compute the LCA disjoint set at <code>cls</code>, noting that we are searching for the LCA of
* <code>uCls</code> and <code>vCls</code>.
*
* @param cls The class we are testing (this is 'u' in the Wiki article)
* @param uCls One of the two classes we are searching for the LCA of. We have simplified the set
* P of pairs to the unity set {uCls,vCls}
* @param vCls One of the two classes we are searching for the LCA of. We have simplified the set
* P of pairs to the unity set {uCls,vCls}
* @param index A data structure mapping resources to disjoint sets (since we can't side-effect
* Jena resources), and which is used to record the LCA pairs
*/
protected static DisjointSet lca(OntClass cls, OntClass uCls, OntClass vCls, LCAIndex index) {
// log.debug( "Entering lca(), cls = " + cls );
DisjointSet clsSet = index.getSet(cls);
if (clsSet.isBlack()) {
// already visited
return clsSet;
}
// not visited yet
clsSet.setAncestor(clsSet);
// for each child of cls
for (Iterator<OntClass> i = cls.listSubClasses(true); i.hasNext(); ) {
OntClass child = i.next();
if (child.equals(cls) || child.equals(cls.getProfile().NOTHING())) {
// we ignore the reflexive case and bottom
continue;
}
// compute the LCA of the sub-tree
DisjointSet v = lca(child, uCls, vCls, index);
// union the two disjoint sets together
clsSet.union(v);
// propagate the distinguished member
clsSet.find().setAncestor(clsSet);
}
// this node is done
clsSet.setBlack();
// are we inspecting one of the elements we're interested in?
if (cls.equals(uCls)) {
checkSolution(uCls, vCls, index);
} else if (cls.equals(vCls)) {
checkSolution(vCls, uCls, index);
}
return clsSet;
}