/** * Get the Subtypes2 inheritance hierarchy database. */ public Subtypes2 getSubtypes2() { return Global.getAnalysisCache().getDatabase(Subtypes2.class); }
@After public void tearDown() { Global.setAnalysisCacheForCurrentThread(null); }
/** * Protected to allow Eclipse plugin remember some cache data for later reuse */ protected void clearCaches() { DescriptorFactory.clearInstance(); ObjectTypeFactory.clearInstance(); TypeQualifierApplications.clearInstance(); TypeQualifierAnnotation.clearInstance(); TypeQualifierValue.clearInstance(); // Make sure the codebases on the classpath are closed AnalysisContext.removeCurrentAnalysisContext(); Global.removeAnalysisCacheForCurrentThread(); IO.close(classPath); }
@Before public void setUp () { Global.setAnalysisCacheForCurrentThread(new NoopAnalysisCache()); }
@SuppressWarnings("unchecked") protected Map<AnalysisLocal<T>, T> getMap() { Map<?, ?> m = Global.getAnalysisCache().getAnalysisLocals(); return (Map<AnalysisLocal<T>, T>) m; }
/** * Create the analysis cache object and register it for current execution thread. * <p> * This method is protected to allow clients override it and possibly reuse * some previous analysis data (for Eclipse interactive re-build) * * @throws IOException * if error occurs registering analysis engines in a plugin */ protected IAnalysisCache createAnalysisCache() throws IOException { IAnalysisCache analysisCache = ClassFactory.instance().createAnalysisCache(classPath, bugReporter); // Register the "built-in" analysis engines registerBuiltInAnalysisEngines(analysisCache); // Register analysis engines in plugins registerPluginAnalysisEngines(detectorFactoryCollection, analysisCache); // Install the DetectorFactoryCollection as a database analysisCache.eagerlyPutDatabase(DetectorFactoryCollection.class, detectorFactoryCollection); Global.setAnalysisCacheForCurrentThread(analysisCache); return analysisCache; } /**
@Override public void report() { if (!Analysis.FIND_EFFECTIVE_RELEVANT_QUALIFIERS) { return; } Global.getAnalysisCache().eagerlyPutDatabase(InterproceduralCallGraph.class, callGraph); } }
public FindUnsatisfiedObligation(BugReporter bugReporter) { this.bugReporter = bugReporter; IAnalysisCache analysisCache = Global.getAnalysisCache(); database = analysisCache.getDatabase(ObligationPolicyDatabase.class); }
/** * @return Returns the database. */ static MethodInfoDatabase getDatabase() { return Global.getAnalysisCache().getDatabase(MethodInfoDatabase.class); } static IdentityHashMap<MethodInfo, Void> getUnconditionalthrowers() {
public FindUselessObjects(BugReporter reporter) { this.reporter = reporter; this.noSideEffectMethods = Global.getAnalysisCache().getDatabase(NoSideEffectMethodsDatabase.class); }
public FindDoubleCheck(BugReporter bugReporter) { this.bugReporter = bugReporter; this.nse = Global.getAnalysisCache().getDatabase(NoSideEffectMethodsDatabase.class); }
public XClass getXClass() throws CheckedAnalysisException { return Global.getAnalysisCache().getClassAnalysis(XClass.class, this); } /**
public FindNoSideEffectMethods(BugReporter bugReporter) { Global.getAnalysisCache().eagerlyPutDatabase(NoSideEffectMethodsDatabase.class, noSideEffectMethods); }
/** * @return Returns the referencedXClass. */ private XClass getReferencedXClass() { if (referencedXClass == null && referencedClass != null) { try { referencedXClass = Global.getAnalysisCache().getClassAnalysis(XClass.class, referencedClass); } catch (CheckedAnalysisException e) { assert true; } } return referencedXClass; } }
public BuildStringPassthruGraph(BugReporter bugReporter) { Global.getAnalysisCache().eagerlyPutDatabase(StringPassthruDatabase.class, cache); }
public DirectlyRelevantTypeQualifiersDatabase getDirectlyRelevantTypeQualifiersDatabase() { return Global.getAnalysisCache().getDatabase(DirectlyRelevantTypeQualifiersDatabase.class); }
public static XClass getXClass(ClassDescriptor c) throws CheckedAnalysisException { return Global.getAnalysisCache().getClassAnalysis(XClass.class, c); }
static XClass getXClass(ClassDescriptor c) throws CheckedAnalysisException { return Global.getAnalysisCache().getClassAnalysis(XClass.class, c); }
protected <E> E getDatabase(Class<E> cls) { return Global.getAnalysisCache().getDatabase(cls); }
@Override public void visitClass(ClassDescriptor classDescriptor) throws CheckedAnalysisException { FBClassReader cr = Global.getAnalysisCache().getClassAnalysis(FBClassReader.class, classDescriptor); this.interfaces = new ArrayList<>(); this.innerClasses = new ArrayList<>(); this.fields = new ArrayList<>(); this.methods = new ArrayList<>(); cr.accept(this, 0); }