Type Members

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

   Exception raised while the analysis is executed.

2.  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.

3.  class DeclaredFields extends AnyRef
4.  class DeclaredMethods extends AnyRef

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

5.  case class FieldAccessInformation(project: SomeProject) extends Product with Serializable

   Acts as a proxy for the propertyStore, accessing FieldReadAccessInformation and FieldWriteAccessInformation.

   Acts as a proxy for the propertyStore, accessing FieldReadAccessInformation and FieldWriteAccessInformation. Should be computed outside of any FPCF phases as it cannot handle intermediate values.

6.  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.

7.  abstract class MethodAnalysisApplication extends ProjectsAnalysisApplication

   A small framework to implement analyses which should be executed for a given set of methods.

8.  final class MethodDeclarationContext extends Ordered[MethodDeclarationContext]

   Encapsulates the information about a non-abstract, 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-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!).

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

   Encapsulates the source of a method.

10.  case class ModuleDefinition[Source](module: ClassFile, source: Option[Source]) extends Product with Serializable
11.  class Project[Source] extends si.Project with 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.)

12.  trait ProjectBasedAnalysis extends si.ProjectBasedAnalysis

    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´.

13.  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.

14.  trait ProjectInformationKey[T <: AnyRef, I <: AnyRef] extends si.ProjectInformationKey[SomeProject, T, I]
15.  type ProjectInformationKeys = Seq[si.ProjectInformationKey[_ <: si.Project, _ <: AnyRef, _ <: AnyRef]]
16.  trait 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.

17.  abstract class ProjectsAnalysisApplication extends AnyRef

    Default command-line runner implementation for analyses to be applied to one or more projects.

    Default command-line runner implementation for analyses to be applied to one or more projects.

    Subclasses can either implement analyze, creating a ReportableAnalysisResult, or override evaluate.

18.  trait ReportableAnalysisResult extends AnyRef

    Result of analyses that can be meaningfully represented using text.

19.  type SomeProject = Project[_]

    Type alias for Projects with arbitrary sources.

20.  type StringConstantsInformation = Map[String, ArraySeq[PCInMethod]]
21.  final class VirtualFormalParameter extends AnyRef

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

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

    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.

    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.

22.  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.