Package edu.umd.cs.findbugs.classfile.impl

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