Class AnalysisCache

  • All Implemented Interfaces:
    IAnalysisCache

    public class AnalysisCache
    extends java.lang.Object
    implements IAnalysisCache
    Implementation of IAnalysisCache. This object is responsible for registering class and method analysis engines and caching analysis results.
    • Field Detail

      • MAX_JAVACLASS_RESULTS_TO_CACHE

        private static final int MAX_JAVACLASS_RESULTS_TO_CACHE
        See Also:
        Constant Field Values
      • MAX_FBCLASSREADER_RESULTS_TO_CACHE

        private static final int MAX_FBCLASSREADER_RESULTS_TO_CACHE
        See Also:
        Constant Field Values
      • MAX_CONSTANT_POOL_GEN_RESULTS_TO_CACHE

        private static final int MAX_CONSTANT_POOL_GEN_RESULTS_TO_CACHE
        See Also:
        Constant Field Values
      • MAX_CLASS_RESULTS_TO_CACHE

        private static final int MAX_CLASS_RESULTS_TO_CACHE
        Maximum number of class analysis results to cache.
        See Also:
        Constant Field Values
      • DEFAULT_RESULTS_TO_CACHE

        private static final int DEFAULT_RESULTS_TO_CACHE
        Maximum number of results to cache. Plugins such as FindSecBugs are using the cache and using an unbounded map can lead to OOM errors on large projects
        See Also:
        Constant Field Values
      • classAnalysisEngineMap

        private final java.util.Map<java.lang.Class<?>,​IClassAnalysisEngine<?>> classAnalysisEngineMap
      • methodAnalysisEngineMap

        private final java.util.Map<java.lang.Class<?>,​IMethodAnalysisEngine<?>> methodAnalysisEngineMap
      • databaseFactoryMap

        private final java.util.Map<java.lang.Class<?>,​IDatabaseFactory<?>> databaseFactoryMap
      • classAnalysisMap

        private final java.util.Map<java.lang.Class<?>,​java.util.Map<ClassDescriptor,​java.lang.Object>> classAnalysisMap
      • databaseMap

        private final java.util.Map<java.lang.Class<?>,​java.lang.Object> databaseMap
      • analysisLocals

        private final java.util.Map<?,​?> analysisLocals
    • Constructor Detail

      • AnalysisCache

        AnalysisCache​(IClassPath classPath,
                      BugReporter errorLogger)
        Constructor.
        Parameters:
        classPath - the IClassPath to load resources from
        errorLogger - the IErrorLogger
    • Method Detail

      • checkedCast

        static <E> E checkedCast​(java.lang.Class<E> analysisClass,
                                 java.lang.Object o)
      • getAllClassAnalysis

        private <E> java.util.Map<ClassDescriptor,​E> getAllClassAnalysis​(java.lang.Class<E> analysisClass)
      • purgeClassAnalysis

        public void purgeClassAnalysis​(java.lang.Class<?> analysisClass)
        Description copied from interface: IAnalysisCache
        Purge all class analysis results of a particular kind
        Specified by:
        purgeClassAnalysis in interface IAnalysisCache
      • dispose

        public void dispose()
        Cleans up all cached data
      • getClassAnalysis

        @CheckForNull
        public java.util.Map<ClassDescriptor,​java.lang.Object> getClassAnalysis​(java.lang.Class<?> analysisClass)
        Parameters:
        analysisClass - non null analysis type
        Returns:
        map with analysis data for given type, can be null
      • reuseClassAnalysis

        public <E> void reuseClassAnalysis​(java.lang.Class<E> analysisClass,
                                           java.util.Map<ClassDescriptor,​java.lang.Object> map)
        Adds the data for given analysis type from given map to the cache
        Parameters:
        analysisClass - non null analysis type
        map - non null, pre-filled map with analysis data for given type
      • getClassAnalysis

        public <E> E getClassAnalysis​(java.lang.Class<E> analysisClass,
                                      @Nonnull
                                      ClassDescriptor classDescriptor)
                               throws CheckedAnalysisException
        Description copied from interface: IAnalysisCache
        Get an analysis of the given class.
        Specified by:
        getClassAnalysis in interface IAnalysisCache
        Type Parameters:
        E - the type of the analysis (e.g., FoobarAnalysis)
        Parameters:
        analysisClass - the analysis class object (e.g., FoobarAnalysis.class)
        classDescriptor - the descriptor of the class to analyze
        Returns:
        the analysis object (e.g., instance of FoobarAnalysis for the class)
        Throws:
        CheckedAnalysisException - if an error occurs performing the analysis
      • probeClassAnalysis

        public <E> E probeClassAnalysis​(java.lang.Class<E> analysisClass,
                                        @Nonnull
                                        ClassDescriptor classDescriptor)
        Description copied from interface: IAnalysisCache
        See if the cache contains a cached class analysis result for given class descriptor.
        Specified by:
        probeClassAnalysis in interface IAnalysisCache
        Parameters:
        analysisClass - analysis result class
        classDescriptor - the class descriptor
        Returns:
        a cached analysis result, or null if there is no cached analysis result
      • hex

        java.lang.String hex​(java.lang.Object o)
      • getMethodAnalysis

        public <E> E getMethodAnalysis​(java.lang.Class<E> analysisClass,
                                       @Nonnull
                                       MethodDescriptor methodDescriptor)
                                throws CheckedAnalysisException
        Description copied from interface: IAnalysisCache
        Get an analysis of the given method.
        Specified by:
        getMethodAnalysis in interface IAnalysisCache
        Type Parameters:
        E - the type of the analysis (e.g., FoobarAnalysis)
        Parameters:
        analysisClass - the analysis class object (e.g., FoobarAnalysis.class)
        methodDescriptor - the descriptor of the method to analyze
        Returns:
        the analysis object (e.g., instance of FoobarAnalysis for the method)
        Throws:
        CheckedAnalysisException - if an error occurs performing the analysis
      • analyzeMethod

        private <E> E analyzeMethod​(ClassContext classContext,
                                    java.lang.Class<E> analysisClass,
                                    MethodDescriptor methodDescriptor)
                             throws CheckedAnalysisException
        Analyze a method.
        Parameters:
        classContext - ClassContext storing method analysis objects for method's class
        analysisClass - class the method analysis object should belong to
        methodDescriptor - method descriptor identifying the method to analyze
        Returns:
        the computed analysis object for the method
        Throws:
        CheckedAnalysisException
      • eagerlyPutMethodAnalysis

        public <E> void eagerlyPutMethodAnalysis​(java.lang.Class<E> analysisClass,
                                                 @Nonnull
                                                 MethodDescriptor methodDescriptor,
                                                 E analysisObject)
        Description copied from interface: IAnalysisCache
        Eagerly put a method analysis object in the cache. This can be necessary if an method analysis engine invokes other analysis engines that might recursively require the analysis being produced.
        Specified by:
        eagerlyPutMethodAnalysis in interface IAnalysisCache
        Type Parameters:
        E - the type of the analysis (e.g., FoobarAnalysis)
        Parameters:
        analysisClass - the analysis class object (e.g., FoobarAnalysis.class)
        methodDescriptor - the descriptor of the method to analyze
      • purgeMethodAnalyses

        public void purgeMethodAnalyses​(@Nonnull
                                        MethodDescriptor methodDescriptor)
        Description copied from interface: IAnalysisCache
        Purge all analysis results for given method. This can be called when a CFG is pruned and we want to compute more accurate analysis results on the new CFG.
        Specified by:
        purgeMethodAnalyses in interface IAnalysisCache
        Parameters:
        methodDescriptor - method whose analysis results should be purged
      • findOrCreateDescriptorMap

        private static <DescriptorType> java.util.Map<DescriptorType,​java.lang.Object> findOrCreateDescriptorMap​(java.util.Map<java.lang.Class<?>,​java.util.Map<DescriptorType,​java.lang.Object>> analysisClassToDescriptorMapMap,
                                                                                                                       java.util.Map<java.lang.Class<?>,​? extends IAnalysisEngine<DescriptorType,​?>> engineMap,
                                                                                                                       java.lang.Class<?> analysisClass)
        Find or create a descriptor to analysis object map.
        Type Parameters:
        DescriptorType - type of descriptor used as the map's key type (ClassDescriptor or MethodDescriptor)
        Parameters:
        analysisClassToDescriptorMapMap - analysis class to descriptor map map
        engineMap - analysis class to analysis engine map
        analysisClass - the analysis map
        Returns:
        the descriptor to analysis object map
      • createMap

        private static <DescriptorType> java.util.Map<DescriptorType,​java.lang.Object> createMap​(java.util.Map<java.lang.Class<?>,​? extends IAnalysisEngine<DescriptorType,​?>> engineMap,
                                                                                                       java.lang.Class<?> analysisClass)
      • registerClassAnalysisEngine

        public <E> void registerClassAnalysisEngine​(java.lang.Class<E> analysisResultType,
                                                    IClassAnalysisEngine<E> classAnalysisEngine)
        Description copied from interface: IAnalysisCache
        Register the given class analysis engine as producing the analysis result type whose Class is given.
        Specified by:
        registerClassAnalysisEngine in interface IAnalysisCache
        Type Parameters:
        E - analysis result type
        Parameters:
        analysisResultType - analysis result type Class object
        classAnalysisEngine - the class analysis engine to register
      • registerMethodAnalysisEngine

        public <E> void registerMethodAnalysisEngine​(java.lang.Class<E> analysisResultType,
                                                     IMethodAnalysisEngine<E> methodAnalysisEngine)
        Description copied from interface: IAnalysisCache
        Register the given method analysis engine as producing the analysis result type whose Class is given.
        Specified by:
        registerMethodAnalysisEngine in interface IAnalysisCache
        Type Parameters:
        E - analysis result type
        Parameters:
        analysisResultType - analysis result type Class object
        methodAnalysisEngine - the method analysis engine to register
      • registerDatabaseFactory

        public <E> void registerDatabaseFactory​(java.lang.Class<E> databaseClass,
                                                IDatabaseFactory<E> databaseFactory)
        Description copied from interface: IAnalysisCache
        Register a database factory.
        Specified by:
        registerDatabaseFactory in interface IAnalysisCache
        Type Parameters:
        E - type of database
        Parameters:
        databaseClass - Class of database
        databaseFactory - the database factory
      • getDatabase

        public <E> E getDatabase​(java.lang.Class<E> databaseClass)
        Description copied from interface: IAnalysisCache
        Get a database. Note: an unchecked analysis exception will be thrown if the database cannot be instantiated. Since instantiation of most kinds of databases simply involves creating an object (and not opening a file or other failure-prone operation), throwing a CheckedAnalysisException creates too great of an exception-handling burden on analyses and detectors which use databases.
        Specified by:
        getDatabase in interface IAnalysisCache
        Type Parameters:
        E - type of database
        Parameters:
        databaseClass - Class of database
        Returns:
        the database (which is created by a database factory if required)
      • getOptionalDatabase

        @CheckForNull
        public <E> E getOptionalDatabase​(java.lang.Class<E> databaseClass)
        Specified by:
        getOptionalDatabase in interface IAnalysisCache
      • getDatabase

        public <E> E getDatabase​(java.lang.Class<E> databaseClass,
                                 boolean optional)
      • eagerlyPutDatabase

        public <E> void eagerlyPutDatabase​(java.lang.Class<E> databaseClass,
                                           E database)
        Description copied from interface: IAnalysisCache
        Eagerly install a database. This avoids the need to register a database factory.
        Specified by:
        eagerlyPutDatabase in interface IAnalysisCache
        Type Parameters:
        E - type of database
        Parameters:
        databaseClass - Class of database
        database - database object