Gets the root unsatisfiable classes.
@return A set of classes that represent the root unsatisfiable classes
3140
public Set<OWLClass> getRootUnsatisfiableClasses() throws ExplanationException {
        StructuralRootDerivedReasoner srd = new StructuralRootDerivedReasoner(manager, baseReasoner, reasonerFactory);
        Set<OWLClass> estimatedRoots = srd.getRootUnsatisfiableClasses();
        cls2JustificationMap = new HashMap<OWLClass, Set<Explanation<OWLAxiom>>>();
        Set<OWLAxiom> allAxioms = new HashSet<OWLAxiom>();
        for (OWLOntology ont : baseReasoner.getRootOntology().getImportsClosure()) {
            allAxioms.addAll(ont.getLogicalAxioms());
        }

        for (OWLClass cls : estimatedRoots) {
            cls2JustificationMap.put(cls, new HashSet<Explanation<OWLAxiom>>());
            System.out.println("POTENTIAL ROOT: " + cls);
        }
        System.out.println("Finding real roots from " + estimatedRoots.size() + " estimated roots");

        int done = 0;
        roots.addAll(estimatedRoots);
        for (final OWLClass estimatedRoot : estimatedRoots) {
            ExplanationGeneratorFactory<OWLAxiom> genFac = ExplanationManager.createExplanationGeneratorFactory(reasonerFactory);
            ExplanationGenerator<OWLAxiom> gen = genFac.createExplanationGenerator(allAxioms);
            OWLDataFactory df = manager.getOWLDataFactory();
            Set<Explanation<OWLAxiom>> expls = gen.getExplanations(df.getOWLSubClassOfAxiom(estimatedRoot, df.getOWLNothing()));
            cls2JustificationMap.get(estimatedRoot).addAll(expls);
            done++;
            System.out.println("Done " + done);
        }
        for(OWLClass clsA : estimatedRoots) {
            for(OWLClass clsB : estimatedRoots) {
                if (!clsA.equals(clsB)) {
                    Set<Explanation<OWLAxiom>> clsAExpls = cls2JustificationMap.get(clsA);
                    Set<Explanation<OWLAxiom>> clsBExpls = cls2JustificationMap.get(clsB);
                    boolean clsARootForClsB = false;
                    boolean clsBRootForClsA = false;
                    // Be careful of cyclic dependencies!
                    for(Explanation<OWLAxiom> clsAExpl : clsAExpls) {
                        for(Explanation<OWLAxiom> clsBExpl : clsBExpls) {
                            if(isRootFor(clsAExpl, clsBExpl)) {
                                // A is a root of B
                                clsARootForClsB = true;
//                                System.out.println(clsB + "  --- depends --->  " + clsA);
                            }
                            else if(isRootFor(clsBExpl, clsAExpl)) {
                                // B is a root of A
                                clsBRootForClsA = true;
//                                System.out.println(clsA + "  --- depends --->  " + clsB);
                            }
                        }
                    }
                    if (!clsARootForClsB || !clsBRootForClsA) {
                        if(clsARootForClsB) {
                            roots.remove(clsB);
                        }
                        else if(clsBRootForClsA) {
                            roots.remove(clsA);
                        }
                    }
                }
            }
        }
        return roots;
    }
157969
public static Set<Class<?>> commonSuperclasses(Iterable<Class<?>> classes) {
        Iterator<Class<?>> it = classes.iterator();
        if (!it.hasNext()) {
            return Collections.emptySet();
        }
        // begin with set from first hierarchy
        Set<Class<?>> result = getSuperclasses(it.next());
        // remove non-superclasses of remaining
        while (it.hasNext()) {
            Class<?> c = it.next();
            Iterator<Class<?>> resultIt = result.iterator();
            while (resultIt.hasNext()) {
                Class<?> sup = resultIt.next();
                if (!sup.isAssignableFrom(c)) {
                    resultIt.remove();
                }
            }
        }
        return result;
    }
520644
public Set<Type> getTypes()
        throws CacheReloadException
    {
        final Set<Type> ret = new HashSet<>();
        for (final Long id : this.types) {
            ret.add(Type.get(id));
        }
        return Collections.unmodifiableSet(ret);
    }
88998
public static OClass getDeepestOClass(Iterable<OClass> classes) {
		if(classes==null) return null;
		OClass ret=null;
		for(OClass oClass: classes) {
			if(ret==null) ret = oClass;
			else {
				if(!ret.equals(oClass) && oClass.isSubClassOf(ret)) ret = oClass;
			}
		}
		return ret;
	}
1182110
public Set<Class<?>> getConcreteClasses() {
        Set<Class<?>> concreteClassSet = new LinkedHashSet<>();

        for ( Class<?> clazz : classes ) {
            if ( isConcrete(clazz) ) {
                concreteClassSet.add(clazz);
            }
        }

        return concreteClassSet;
    }
652383
protected Set<Class<? extends Annotation>> getSupportedAnnotationClasses() {
		Set<Class<? extends Annotation>> annotations = new LinkedHashSet<Class<? extends Annotation>>();

		annotations.addAll(typeProcessor.getSupportedAnnotationClasses());
		annotations.addAll(sharedPreferencesProcessor.getSupportedAnnotationClasses());
		annotations.addAll(dataSourceProcessor.getSupportedAnnotationClasses());
		annotations.addAll(many2ManyProcessor.getSupportedAnnotationClasses());

		return annotations;
	}
92006
@Exported
    public Set<Node> getNodes() {
        Set<Node> nodes = this.nodes;
        if(nodes!=null) return nodes;

        Set<Node> r = new HashSet<>();
        Jenkins h = Jenkins.getInstance();
        if(this.matches(h))
            r.add(h);
        for (Node n : h.getNodes()) {
            if(this.matches(n))
                r.add(n);
        }
        return this.nodes = Collections.unmodifiableSet(r);
    }
206622
public TypeDesc[] getExceptions() {
        if (mExceptions == null) {
            return new TypeDesc[0];
        }

        ConstantClassInfo[] classes = mExceptions.getExceptions();
        TypeDesc[] types = new TypeDesc[classes.length];
        for (int i=0; i<types.length; i++) {
            types[i] = classes[i].getType();
        }

        return types;
    }
312906
public final Set<String> getAsHTMLClassSet() {
		Set<String> htmlClasses = new HashSet<>();
		final String htmlClassPrefix = "wc-margin-";
		final String topClassModifier = "n-";
		final String rightClassModifier = "e-";
		final String bottomClassModifier = "s-";
		final String leftClassModifier = "w-";

		Size current = getTop();
		if (current != null) {
			htmlClasses.add(htmlClassPrefix.concat(topClassModifier).concat(current.toString()));
		}
		current = getRight();
		if (current != null) {
			htmlClasses.add(htmlClassPrefix.concat(rightClassModifier).concat(current.toString()));
		}
		current = getBottom();
		if (current != null) {
			htmlClasses.add(htmlClassPrefix.concat(bottomClassModifier).concat(current.toString()));
		}
		current = getLeft();
		if (current != null) {
			htmlClasses.add(htmlClassPrefix.concat(leftClassModifier).concat(current.toString()));
		}

		if (htmlClasses.isEmpty()) {
			return null;
		}
		return htmlClasses;
	}
1213958
public static List<Class<?>> lowestCommonSuperclasses(Iterable<Class<?>> classes) {
        Collection<Class<?>> commonSupers = commonSuperclasses(classes);
        return lowestClasses(commonSupers);
    }
13539
public Map getPathClasses()
	{
		if (m_pathClasses.isEmpty())
		{
			if (m_parentCriteria == null)
			{
				if (m_query == null)
				{
					return m_pathClasses;
				}
				else
				{
					return m_query.getPathClasses();
				}
			}
			else
			{
				return m_parentCriteria.getPathClasses();
			}
		}
		else
		{
			return m_pathClasses;
		}
	}
209028
public List<GetterType<BeanType<T>>> getAllGetter()
   {
      List<GetterType<BeanType<T>>> list = new ArrayList<GetterType<BeanType<T>>>();
      List<Node> nodeList = childNode.get("getter");
      for(Node node: nodeList)
      {
         GetterType<BeanType<T>>  type = new GetterTypeImpl<BeanType<T>>(this, "getter", childNode, node);
         list.add(type);
      }
      return list;
   }
1136491
public List<ImmutableFunctionalTerm> getClassPredicates() {
		List<ImmutableFunctionalTerm> classes = new ArrayList<>();
		for (ImmutableFunctionalTerm p : classPredicates)
			classes.add(p);
		classPredicates.clear();
		return classes;
	}
1235009
public List<Classification.RuntimeClassification> getClassifications() {
    List<Classification.RuntimeClassification> result = new ArrayList<>();
    getClassifications(result, tree.getRoot());
    return result;
  }
1135316
public static List<ClassLoader> getClassLoaders() {
        ClassLoader[] classLoaders = new ClassLoader[2];
        classLoaders[0] = FileUtils.class.getClassLoader();
        classLoaders[1] = Thread.currentThread().getContextClassLoader();

        // Clean up possible null values. Note that #getClassLoader may return a null value.
        List<ClassLoader> loaders = new ArrayList<ClassLoader>(classLoaders.length);
        for (ClassLoader classLoader : classLoaders) {
            if (classLoader != null) {
                loaders.add(classLoader);
            }
        }
        return loaders;
    }
271460
public List<String> getClasses(){
		List<String> classes = new ArrayList<String>();
		for (XmlClass xmlClass : xmlJmapper.classes) 
			classes.add(xmlClass.name);
		return classes;
	}
340402
public List<IfClassNotAvailable<Exclude<T>>> getAllIfClassNotAvailable()
   {
      List<IfClassNotAvailable<Exclude<T>>> list = new ArrayList<IfClassNotAvailable<Exclude<T>>>();
      List<Node> nodeList = childNode.get("if-class-not-available");
      for(Node node: nodeList)
      {
         IfClassNotAvailable<Exclude<T>>  type = new IfClassNotAvailableImpl<Exclude<T>>(this, "if-class-not-available", childNode, node);
         list.add(type);
      }
      return list;
   }