/**
   * 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;
  }