Type Members

1.  trait Analysis[Source, +AnalysisResult] extends AnyRef

   Common trait that analyses can inherit from when they want to use the general analysis framework AnalysisExecutor.

   Common trait that analyses can inherit from when they want to use the general analysis framework AnalysisExecutor.

   Conceptual Idea

   An analysis is basically a mapping of a Project's resources to some result.

   Each analysis can produce (optionally) some result. E.g., a text describing a scenario that leads to a bug, a graph, a report that identifies a specific line or a combination thereof.

   However, an analysis should never rely on the location of a resource. If an analysis needs access to further resources, it should use the Project class.

2.  class AnalysisAggregator[Source, AnalysisResult] extends Analysis[Source, Iterable[AnalysisResult]]

   Aggregates several analyses such that they are treated as one afterwards.

   Aggregates several analyses such that they are treated as one afterwards.

   Thread Safety

   This class is thread safe.

   Implementation Note

   If you extend this class, make sure that all access to this class' (mutable) fields/ mutable data structures is synchronized on this.

3.  case class AnalysisException(message: String, cause: Throwable = null) extends RuntimeException with Product with Serializable

   Exception raised while the analysis is executed.

4.  trait AnalysisExecutor extends AnyRef

   Provides the necessary infrastructure to easily execute a given analysis that generates some analysis result that can be printed on the command line.

   Provides the necessary infrastructure to easily execute a given analysis that generates some analysis result that can be printed on the command line.

   To facilitate the usage of this trait several implicit conversions are defined that wrap standard analyses (org.opalj.br.analyses) such that they report results that are reportable.

   This class distinguishes between class files belonging to the code base under analysis and those that belong to the libraries. Those belonging to the libraries are loaded using the ClassFileReader for library classes (basically, all method bodies are skipped org.opalj.br.reader.Java8LibraryFramework). The parameter to specify library classes is -libcp=, the parameter to specify the "normal" classpath is -cp=.

   Control Flow

   1. The standard parameters are checked.
   2. The analysis is called to let it verify the analysis specific parameters.
   3. The Project is created.
   4. The analyze method of the Analysis is called with the project and the parameters.
   5. The results are printed.
5.  case class BasicReport(toConsoleString: String) extends ReportableAnalysisResult with Product with Serializable

   Result of some analysis that just consists of some text.

   Result of some analysis that just consists of some text.

   toConsoleString

   A string printed to the console.

6.  class DeclaredMethods extends AnyRef

   The set of all org.opalj.br.DeclaredMethods (potentially used by the property store).

7.  abstract class DefaultOneStepAnalysis extends AnalysisExecutor with OneStepAnalysis[URL, ReportableAnalysisResult]

   Default implementation of the AnalysisExecutor which facilitates the development of analyses which are executed in one step.

8.  class FieldAccessInformation extends AnyRef

   Stores the information where each field is read and written.

   Stores the information where each field is read and written. If the project is incomplete the results are also necessarily incomplete. Reflective and comparable accesses are not considered.

9.  case class InconsistentProjectException(message: String, severity: Level = Warn) extends Exception with Product with Serializable

   Thrown when the framework determines that the project is not consistent.

10.  class JavaProject extends AnyRef

    Enables the querying of a project.

    Enables the querying of a project.

    Note

    The interface of this class was designed with Java interoperability in mind!

11.  final class MethodDeclarationContext extends Ordered[MethodDeclarationContext]

    Encapsulates the information about a non-abstract, non-private, non-static method which is not an initializer (<(cl)init>) and which is required when determining potential call targets.

    Encapsulates the information about a non-abstract, non-private, non-static method which is not an initializer (<(cl)init>) and which is required when determining potential call targets.

    Note

    A class may have -- w.r.t. a given package name -- at most one package visible method which has a specific name and descriptor combination. For methods with protected or public visibility a class always has at most one method with a given name and descriptor.

    ,

    Equality is defined based on the name, descriptor and declaring package of a method (the concrete declaring class is not considered!).

12.  case class MethodInfo[Source](source: Source, method: Method) extends Product with Serializable

    Encapsulates the source of a method.

13.  case class ModuleDefinition[Source](module: ClassFile, source: Option[Source]) extends Product with Serializable
14.  type MultipleResultsAnalysis[Source, +AnalysisResult] = Analysis[Source, Iterable[AnalysisResult]]

    An analysis that may produce multiple results.

    An analysis that may produce multiple results. E.g., an analysis that looks for instances of bug patterns.

15.  trait OneStepAnalysis[Source, +AnalysisResult] extends Analysis[Source, AnalysisResult]

    An analysis that performs all computations in one step.

    An analysis that performs all computations in one step. Only very short-running analyses should use this interface as reporting progress is not supported.

16.  type ProgressEvent = analyses.ProgressEvents.Value
17.  trait ProgressManagement extends AnyRef

    Enables the management of the progress of a long running computation.

    Enables the management of the progress of a long running computation. Typically a long running progress such as an analysis is expected to report progress every 250 to 2000 milliseconds. It should -- however -- check every ~100 milliseconds the interrupted status to enable a timely termination.

    This trait defines a call-back interface that is implemented by some class that runs an analysis and which passes an instance of it to some analysis to report progress.

    Note

    Implementations of this class must be thread safe if the analysis is multi- threaded.

    ,

    Implementations must handle the case where a step that was started later finishes earlier than a previous step. In other words, even if the last step has ended, that does not mean that the analysis as a whole has already finished. Instead an implementation has to track how many steps have ended to determine when the whole analysis has ended.

18.  class Project[Source] extends ProjectLike

    Primary abstraction of a Java project; i.e., a set of classes that constitute a library, framework or application as well as the libraries or frameworks used by the former.

    Primary abstraction of a Java project; i.e., a set of classes that constitute a library, framework or application as well as the libraries or frameworks used by the former.

    This class has several purposes:

    1. It is a container for ClassFiles.
    2. It directly gives access to the project's class hierarchy.
    3. It serves as a container for project-wide information (e.g., a call graph, information about the mutability of classes, constant values,...) that can be queried using org.opalj.br.analyses.ProjectInformationKeys. The list of project wide information that can be made available is equivalent to the list of (concrete/singleton) objects implementing the trait org.opalj.br.analyses.ProjectInformationKey. One of the most important project information keys is the PropertyStoreKey which gives access to the property store.

    Thread Safety

    This class is thread-safe.

    Prototyping Analyses/Querying Projects

    Projects can easily be created and queried using the Scala REPL. For example, to create a project, you can use:

    val project = org.opalj.br.analyses.Project(org.opalj.bytecode.JRELibraryFolder)

    Now, to determine the number of methods that have at least one parameter of type int, you can use:

    project.methods.filter(_.parameterTypes.exists(_.isIntegerType)).size

    Source

    The type of the source of the class file. E.g., a URL, a File, a String or a Pair (JarFile,JarEntry). This information is needed for, e.g., presenting users meaningful messages w.r.t. the location of issues. We abstract over the type of the resource to facilitate the embedding in existing tools such as IDEs. E.g., in Eclipse IResource's are used to identify the location of a resource (e.g., a source or class file.)

19.  trait ProjectBasedAnalysis extends AnyRef

    Common super trait of all analyses that use the fixpoint computations framework.

    Common super trait of all analyses that use the fixpoint computations framework. In general, an analysis computes a org.opalj.fpcf.Property by processing some entities, e.g.: ´classes´, ´methods´ or ´fields´.

20.  class ProjectIndex extends AnyRef

    An index that enables the efficient lookup of source elements (methods and fields) given the method's/field's name and the descriptor/field type.

    An index that enables the efficient lookup of source elements (methods and fields) given the method's/field's name and the descriptor/field type. The index contains fields with public, protected, <default> and private visibility.

    Basically an index of the source elements (methods and fields) of a project.

    This index can be used, e.g., to resolve method calls based on the method's names and/or descriptors.

    To get an instance of a project index call Project.get and pass in the ProjectIndexKey object.

    See also

    FieldAccessInformation to get the information where a field is accessed.

21.  trait ProjectInformationKey[T <: AnyRef, I <: AnyRef] extends AnyRef

    ProjecInformationKey objects are used to get/associate some (immutable) information with a project that should be computed on demand.

    ProjecInformationKey objects are used to get/associate some (immutable) information with a project that should be computed on demand. For example, imagine that you write an analysis that requires – as a foundation – the project's call graph. In this case, to get the call graph it is sufficient to pass the respective key to the Project object. If the call graph was already computed that one will be returned, otherwise the computation will be performed and the result will be cached for future usage before it is returned.

    Using Project Information

    If access to some project information is required, it is sufficient to use the (singleton) instance of the respective ProjectInformationKey to get the respective project information.

    For example, let's assume that an index of all fields and methods is needed. In this case the code to get the index would be:

    import ...{ProjectIndex,ProjectIndexKey}
    val project : Project = ???
    val projectIndex = project.get(ProjectIndexKey)
    // do something with the index

    Providing Project Information/Implementing ProjectInformationKey

    Making project wide information available on demand is done as follows.

    1. Implement the base analysis that computes the information given some project.
    2. Implement your ProjectInformationKey class that inherits from this trait and which calls the base analysis. It is recommended that the factory method (compute) is side-effect free.

    Threading

    Project takes care of threading related issues. The methods requirements and compute will never be called concurrently w.r.t. the same project object. However, concurrent calls may happen w.r.t. two different project objects.

    Caching

    Project takes care of the caching of the result of the computation of the information.

    T

    The type of the information object that is derived.

    I

    The type of information used at initialization time.

22.  type ProjectInformationKeys = Seq[ProjectInformationKey[_ <: AnyRef, _ <: AnyRef]]
23.  abstract class ProjectLike extends ClassFileRepository

    Enables project wide lookups of methods and fields as required to determine the target(s) of an invoke or field access instruction.

    Enables project wide lookups of methods and fields as required to determine the target(s) of an invoke or field access instruction.

    Note

    The current implementation is based on the correct project assumption; i.e., if the bytecode of the project as a whole is not valid, the result is generally undefined. Just one example of a violation of the assumption would be, if we have two interfaces which define a non-abstract method with the same signature and both interfaces are implemented by a third interface which does not override these methods. In this case the result of a resolveMethodReference is not defined, because the code base as a whole is not valid.

24.  case class ReportableAnalysisAdapter[Source, AnalysisResult](analysis: Analysis[Source, AnalysisResult], converter: (AnalysisResult) ⇒ String) extends Analysis[Source, ReportableAnalysisResult] with Product with Serializable
    Source

    The type of the underlying source file.

    See also

    org.opalj.br.analyses for several predefined converter functions.

25.  trait ReportableAnalysisResult extends AnyRef

    Result of analyses that can be meaningfully represented using text.

26.  type SingleOptionalResultAnalysis[Source, +AnalysisResult] = Analysis[Source, Option[AnalysisResult]]

    An analysis that may produce a result.

27.  type SomeProject = Project[_]

    Type alias for Project's with an arbitrary sources.

28.  type StringConstantsInformation = Map[String, ConstArray[PCInMethod]]
29.  final class VirtualFormalParameter extends AnyRef

    Explicitly models a formal parameter of an virtual method to make it possible to store it in the property store and to compute properties for it.

    Explicitly models a formal parameter of an virtual method to make it possible to store it in the property store and to compute properties for it. In contrast to the VirtualFormalParameter, which models a parameter of a concrete method, virtual methods include every possible method that overrides the method attached to the VirtualForwardingMethod.

    The first parameter explicitly defined by the method will have the origin -2, the second one will have the origin -3 and so on. That is, the origin of an explicitly declared parameter is always -(parameter_index + 2). The origin of the this parameter is -1.

    It should be used to aggregate the properties for every VirtualFormalParameter of a method included in this virtual method.

    Note

    The computational type category of the parameters is ignored to ease the mapping.

    ,

    This encoding is also used by the default three address code representation generated using a local data-flow analysis (see org.opalj.tac.TACAI). In case of the bytecode based data-flow analysis the origin used by the analysis reflects the position of the parameter value on the tac; see org.opalj.ai.parameterIndexToValueOrigin.

30.  class VirtualFormalParameters extends AnyRef

    The set of all explicit and implicit virtual formal method parameters in a project.

    The set of all explicit and implicit virtual formal method parameters in a project. The set also contains virtual formal parameters of library methods.