Packages

  • package root
    Definition Classes
    root
  • package org
    Definition Classes
    root
  • package opalj

    OPAL is a Scala-based framework for the static analysis, manipulation and creation of Java bytecode.

    OPAL is a Scala-based framework for the static analysis, manipulation and creation of Java bytecode. OPAL is designed with performance, scalability and adaptability in mind.

    Its main components are:

    • a library (Common) which provides generally useful data-structures and algorithms for static analyses.
    • a framework for implementing lattice based static analyses (Static Analysis Infrastructure)
    • a framework for parsing Java bytecode (Bytecode Infrastructure) that can be used to create arbitrary representations.
    • a library to create a one-to-one in-memory representation of Java bytecode (Bytecode Disassembler).
    • a library to create a representation of Java bytecode that facilitates writing simple static analyses (Bytecode Representation - org.opalj.br).
    • a scalable, easily customizable framework for the abstract interpretation of Java bytecode (Abstract Interpretation Framework - org.opalj.ai).
    • a library to extract dependencies between code elements and to facilitate checking architecture definitions.
    • a library for the lightweight manipulation and creation of Java bytecode (Bytecode Assembler).

    General Design Decisions

    Thread Safety

    Unless explicitly noted, OPAL is thread safe. I.e., the classes defined by OPAL can be considered to be thread safe unless otherwise stated. (For example, it is possible to read and process class files concurrently without explicit synchronization on the client side.)

    No null Values

    Unless explicitly noted, OPAL does not null values I.e., fields that are accessible will never contain null values and methods will never return null. If a method accepts null as a value for a parameter or returns a null value it is always explicitly documented. In general, the behavior of methods that are passed null values is undefined unless explicitly documented.

    No Typecasts for Collections

    For efficiency reasons, OPAL sometimes uses mutable data-structures internally. After construction time, these data-structures are generally represented using their generic interfaces (e.g., scala.collection.{Set,Map}). However, a downcast (e.g., to add/remove elements) is always forbidden as it would effectively prevent thread-safety. Furthermore, the concrete data-structure is always considered an implementation detail and may change at any time.

    Assertions

    OPAL makes heavy use of Scala's Assertion Facility to facilitate writing correct code. Hence, for production builds (after thorough testing(!)) it is highly recommend to build OPAL again using -Xdisable-assertions.

    Definition Classes
    org
  • package br

    In this representation of Java bytecode references to a Java class file's constant pool and to attributes are replaced by direct references to the corresponding constant pool entries.

    In this representation of Java bytecode references to a Java class file's constant pool and to attributes are replaced by direct references to the corresponding constant pool entries. This facilitates developing analyses and fosters comprehension.

    Based on the fact that indirect references to constant pool entries are resolved and replaced by direct references this representation is called the resolved representation.

    This representation of Java bytecode is considered as OPAL's standard representation for writing Scala based analyses. This representation is engineered such that it facilitates writing analyses that use pattern matching.

    Definition Classes
    opalj
  • package analyses

    Defines commonly useful type aliases.

    Defines commonly useful type aliases.

    Definition Classes
    br
  • package cg
    Definition Classes
    analyses
  • package observers
    Definition Classes
    analyses
  • Analysis
  • AnalysisAggregator
  • AnalysisException
  • AnalysisExecutor
  • BasicMethodInfo
  • BasicReport
  • CovariantEqualsMethodDefined
  • CovariantEqualsMethodDefinedAnalysis
  • DeclaredMethods
  • DeclaredMethodsKey
  • DefaultOneStepAnalysis
  • FieldAccessInformation
  • FieldAccessInformationAnalysis
  • FieldAccessInformationKey
  • InconsistentProjectException
  • JavaProject
  • MethodDeclarationContext
  • MethodDeclarationContextOrdering
  • MethodInfo
  • ModuleDefinition
  • MoreCheckers
  • OneStepAnalysis
  • ProgressEvents
  • ProgressManagement
  • Project
  • ProjectBasedAnalysis
  • ProjectDemo
  • ProjectIndex
  • ProjectIndexKey
  • ProjectIndexStatistics
  • ProjectInformationKey
  • ProjectLike
  • ProjectTypeConfigFactory
  • ReportableAnalysisAdapter
  • ReportableAnalysisResult
  • SimpleProjectStatistics
  • StringConstantsInformationKey
  • VirtualFormalParameter
  • VirtualFormalParameters
  • VirtualFormalParametersKey

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.

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

Source
Project.scala
Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Project
  2. ProjectLike
  3. ClassFileRepository
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final val MethodHandleClassFile: Option[ClassFile]

    The class file of java.lang.invoke.MethodHandle, if available.

    The class file of java.lang.invoke.MethodHandle, if available.

    Definition Classes
    ProjectProjectLike
  5. final val MethodHandleSubtypes: Set[ObjectType]

    The set of all subtypes of java.lang.invoke.MethodHandle; in particular required to resolve signature polymorphic method calls.

    The set of all subtypes of java.lang.invoke.MethodHandle; in particular required to resolve signature polymorphic method calls.

    Definition Classes
    ProjectProjectLike
  6. final val ObjectClassFile: Option[ClassFile]

    The class file of java.lang.Object, if available.

    The class file of java.lang.Object, if available.

    Definition Classes
    ProjectProjectLike
  7. final val allClassFiles: Iterable[ClassFile]
  8. final val allFields: Iterable[Field]
  9. final val allLibraryClassFiles: ConstArray[ClassFile]
  10. final val allMethods: Iterable[Method]
  11. final val allMethodsWithBody: ConstArray[Method]
  12. final val allMethodsWithBodyWithContext: ConstArray[MethodInfo[Source]]
  13. final val allProjectClassFiles: ConstArray[ClassFile]
  14. final val allSourceElements: Iterable[SourceElement]
  15. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  16. def availableProjectInformation: List[AnyRef]

    Returns the additional project information that is currently available.

    Returns the additional project information that is currently available.

    If some analyses are still running it may be possible that additional information will be made available as part of the execution of those analyses.

    Note

    This method redetermines the available project information on each call.

  17. def classFile(objectType: ObjectType): Option[ClassFile]

    Returns the class file that defines the given objectType; if any.

    Returns the class file that defines the given objectType; if any.

    objectType

    Some object type.

    Definition Classes
    ProjectClassFileRepository
  18. final val classFilesCount: Int
  19. def classFilesWithSources: Iterable[(ClassFile, Source)]
  20. final val classHierarchy: ClassHierarchy
    Definition Classes
    ProjectProjectLike
  21. final val classesPerPackage: Map[String, Set[ClassFile]]

    The set of all classes defined in a specific package.

  22. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  23. final val codeSize: Long
  24. implicit final val config: Config
  25. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  26. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  27. def extend(other: Project[Source]): Project[Source]

    Creates a new Project which also includes this as well as the other project's class files.

  28. def extend(projectClassFilesWithSources: Iterable[(ClassFile, Source)]): Project[Source]

    Creates a new Project which also includes the given class files.

  29. final val fieldsCount: Int
  30. def finalize(): Unit

    Unregisters this project from the OPALLogger and then calls super.finalize.

    Unregisters this project from the OPALLogger and then calls super.finalize.

    Attributes
    protected
    Definition Classes
    Project → AnyRef
  31. def findMaximallySpecificSuperinterfaceMethods(superinterfaceTypes: UIDSet[ObjectType], name: String, descriptor: MethodDescriptor, analyzedSuperinterfaceTypes: UIDSet[ObjectType]): (UIDSet[ObjectType], Set[Method])

    Computes the maximally specific superinterface method with the given name and descriptor

    Computes the maximally specific superinterface method with the given name and descriptor

    superinterfaceTypes

    A set of interfaces which potentially declare a method with the given name and descriptor.

    Definition Classes
    ProjectLike
  32. def findMaximallySpecificSuperinterfaceMethods(superinterfaceType: ObjectType, name: String, descriptor: MethodDescriptor, analyzedSuperinterfaceTypes: UIDSet[ObjectType] = UIDSet.empty): (UIDSet[ObjectType], Set[Method])

    Computes the set of maximally specific superinterface methods with the given name and descriptor.

    Computes the set of maximally specific superinterface methods with the given name and descriptor.

    Definition Classes
    ProjectLike
    Note

    This method does not consider methods defined by java.lang.Object! Those methods have precedence over respective methods defined by superinterfaces! A corresponding check needs to be done before calling this method.

  33. final lazy val functionalInterfaces: UIDSet[ObjectType]

    Computes the set of all definitive functional interfaces in a top-down fashion.

    Computes the set of all definitive functional interfaces in a top-down fashion.

    returns

    The functional interfaces.

    See also

    Java 8 language specification for details!

  34. def get[T <: AnyRef](pik: ProjectInformationKey[T, _]): T

    Returns the information attached to this project that is identified by the given ProjectInformationKey.

    Returns the information attached to this project that is identified by the given ProjectInformationKey.

    If the information was not yet required, the information is computed and returned. Subsequent calls will directly return the information.

    Note

    (Development Time) Every analysis using ProjectInformationKeys must list All requirements; failing to specify a requirement can end up in a deadlock.

    See also

    ProjectInformationKey for further information.

  35. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  36. def getOrCreateProjectInformationKeyInitializationData[T <: AnyRef, I <: AnyRef](key: ProjectInformationKey[T, I], info: ⇒ I): I

    Gets the project information key specific initialization object.

    Gets the project information key specific initialization object. If an object is already registered, that object will be used otherwise info will be evaluated and that value will be added and also returned.

    Note

    Initialization data is discarded once the key is used.

  37. def getProjectInformationKeyInitializationData[T <: AnyRef, I <: AnyRef](key: ProjectInformationKey[T, I]): Option[I]

    Returns the project specific initialization information for the given project information key.

  38. def groupedClassFilesWithMethodsWithBody(groupsCount: Int): Array[Buffer[ClassFile]]

    Distributes all classes which define methods with bodies across a given number of groups.

    Distributes all classes which define methods with bodies across a given number of groups. Afterwards these groups can, e.g., be processed in parallel.

  39. def has[T <: AnyRef](pik: ProjectInformationKey[T, _]): Option[T]

    Tests if the information identified by the given ProjectInformationKey is available.

    Tests if the information identified by the given ProjectInformationKey is available. If the information is not (yet) available, the information will not be computed; None will be returned.

    See also

    ProjectInformationKey for further information.

  40. def hasVirtualMethod(objectType: ObjectType, method: Method): Answer

    Tests if the given method belongs to the interface of an object identified by the given objectType.

    Tests if the given method belongs to the interface of an object identified by the given objectType. I.e., returns true if a virtual method call, where the receiver type is known to have the given objectType, would lead to the direct invocation of the given method. The given method can be an inherited method, but it will never return Yes if the given method is overridden by objectType or a supertype of it which is a sub type of the declaring type of method.

    Definition Classes
    ProjectLike
    Note

    The computation is based on the computed set of instanceMethods and generally requires at most O(n log n) steps where n is the number of callable instance methods of the given object type; the class hierarchy is not traversed.

  41. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  42. def instanceCall(callerClassType: ObjectType, receiverType: ReferenceType, name: String, descriptor: MethodDescriptor): Result[Method]

    Returns the (instance) method that would be called when we have an instance of the given receiver type.

    Returns the (instance) method that would be called when we have an instance of the given receiver type. I.e., using this method is suitable only when the runtime type, which is the receiver of the method call, is precisely known!

    Examples

    class A {def foo() = {} }
    class B extends A {/*inherits, but does not override foo()*/}
    class C extends B { def foo() = {} }
    val b = new B();
    b.foo() // <= in this case the method defined by A will be returned.
    val c = new C();
    c.foo() // <= in this case the method defined by C will be returned.

    This method supports default methods and signature polymorphic calls; i.e., the descriptor of the retuned methods may not be equal to the given method descriptor.

    callerClassType

    The object type which defines the method which performs the call. This information is required if the call target has (potentially) default visibility. (Note that this - in general - does not replace the need to perform an accessibility check.)

    receiverType

    A class type or an array type; never an interface type.

    Definition Classes
    ProjectLike
  43. final val instanceMethods: Map[ObjectType, ConstArray[MethodDeclarationContext]]

    Returns the set of all non-private, non-abstract, non-static methods that are not initializers and which are potentially callable by clients when we have an object that has the specified type and a method is called using org.opalj.br.instructions.INVOKEINTERFACE, org.opalj.br.instructions.INVOKEVIRTUAL or org.opalj.br.instructions.INVOKEDYNAMIC.

    Returns the set of all non-private, non-abstract, non-static methods that are not initializers and which are potentially callable by clients when we have an object that has the specified type and a method is called using org.opalj.br.instructions.INVOKEINTERFACE, org.opalj.br.instructions.INVOKEVIRTUAL or org.opalj.br.instructions.INVOKEDYNAMIC.

    The array of methods is sorted using MethodDeclarationContextOrdering to enable fast look-up of the target method. (See MethodDeclarationContext's compareAccessibilityAware method for further details.)

    Definition Classes
    ProjectProjectLike
  44. def interfaceCall(declaringClass: ObjectType, name: String, descriptor: MethodDescriptor): Set[Method]

    Returns the methods that may be called by an org.opalj.br.instructions.INVOKEINTERFACE call if the precise runtime type is not known.

    Returns the methods that may be called by an org.opalj.br.instructions.INVOKEINTERFACE call if the precise runtime type is not known. (If the precise runtime type is known, use instanceCall to get the target method.)

    returns

    The set of potentially called methods. The set will be empty if the target class is not defined as part of the analyzed code base.

    Definition Classes
    ProjectLike
    Note

    Caching the result (in particular when the call graph is computed) is recommended as the computation is expensive. In other words, this function is meant to be used as a foundation for call graph construction algorithms.

    ,

    Keep in mind that the following is legal (byte)code:

    class X { void m(){ System.out.println("X.m"); } }
    interface I { void m(); }
    class Z extends X implements I {}

    Hence, we also have to consider inherited methods and just considering the methods defined by subclasses is not sufficient! In other words, the result can contain methods (here, X.m) defined by classes which are not subtypes of the given interface type!

  45. def interfaceCall(i: INVOKEINTERFACE): Set[Method]
    Definition Classes
    ProjectLike
  46. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  47. def isLibraryType(objectType: ObjectType): Boolean

    Returns true if the given type belongs to the library part of the project.

    Returns true if the given type belongs to the library part of the project. This is generally the case if no class file was loaded for the given type.

  48. def isLibraryType(classFile: ClassFile): Boolean

    Returns true if the given class file belongs to the library part of the project.

    Returns true if the given class file belongs to the library part of the project. This is only the case if the class file was explicitly identified as being part of the library. By default all class files are considered to belong to the code base that will be analyzed.

  49. def isProjectType(objectType: ObjectType): Boolean

    Returns true iff the given type belongs to the project and not to a library.

  50. def isSignaturePolymorphic(definingClassType: ObjectType, method: Method): Boolean

    Returns true if the method defined by the given class type is a signature polymorphic method.

    Returns true if the method defined by the given class type is a signature polymorphic method. (See JVM 8 Spec. for details.) //TODO JAVA 8+

    Definition Classes
    ProjectLike
  51. final val libraryClassFilesAreInterfacesOnly: Boolean
  52. final val libraryClassFilesCount: Int
  53. def libraryClassFilesWithSources: Iterable[(ClassFile, Source)]
  54. final val libraryFieldsCount: Int
  55. final val libraryMethodsCount: Int
  56. def libraryPackages: Set[String]

    Returns the set of all library packages that contain at least one class.

    Returns the set of all library packages that contain at least one class.

    For example, in case of the JDK the package java does not directly contain any class – only its subclasses. This package is, hence, not returned by this function, but the package java.lang is.

    Note

    This method's result is not cached.

  57. implicit final val logContext: LogContext
    Definition Classes
    ProjectClassFileRepository
  58. def lookupClassFiles(objectTypes: Traversable[ObjectType])(classFileFilter: (ClassFile) ⇒ Boolean): Traversable[ClassFile]

    Returns all available ClassFile objects for the given objectTypes that pass the given filter.

    Returns all available ClassFile objects for the given objectTypes that pass the given filter. ObjectTypes for which no ClassFile is available are ignored.

  59. def lookupVirtualMethod(callingContextType: ObjectType, receiverType: ObjectType, name: String, descriptor: MethodDescriptor): Result[MethodDeclarationContext]

    Looks up the method (declaration context) which is accessible/callable by an org.opalj.br.instructions.INVOKEVIRTUAL or org.opalj.br.instructions.INVOKEINTERFACE call which was done by a method belonging to callingContextType.

    Looks up the method (declaration context) which is accessible/callable by an org.opalj.br.instructions.INVOKEVIRTUAL or org.opalj.br.instructions.INVOKEINTERFACE call which was done by a method belonging to callingContextType. The callingContextType is only relevant in case the target method has default visibility; in this case it is checked whether the caller belongs to the same context.

    returns

    Success if the method is found; Empty$ if the method cannot be found and Failure$ if the method cannot be found because the project is definitively inconsistent. Failure$ is used on a best-effort basis.

    Definition Classes
    ProjectLike
    Note

    This method uses the pre-computed information about instance methods and, therefore, does not require a type hierarchy based lookup.

    ,

    It supports the lookup of polymorphic methods.

  60. def methodNames(objectTypes: Traversable[ObjectType]): Set[String]

    The set of all method names of the given types.

  61. final val methodsCount: Int
  62. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  63. def nonVirtualCall(i: NonVirtualMethodInvocationInstruction): Result[Method]
    Definition Classes
    ProjectLike
  64. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  65. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  66. def overriddenBy(m: Method): Set[Method]

    Returns the set of methods which directly override the given method.

    Returns the set of methods which directly override the given method. Note that overriddenBy is not context aware. I.e., if a given method m is an interface method, then it may happen that we have an implementation of that method in a class which is inherited from a superclass which is not a subtype of the interface. That method - since it is not defined by a subtype of the interface - would not be included in the returned set. An example is shown next:

    class X { void m(){ System.out.println("X.m"); }
    interface Y { default void m(){ System.out.println("Y.m"); }
    class Z extends X implements Y {
     // Z inherits m() from X; hence, X.m() (in this context) "overrides" Y.m(), but is not
     // returned by this function. To also identify X.m() you have to combine the results
     // of overridenBy and instanceMethods(!).
    }
    Definition Classes
    ProjectLike
  67. final val overridingMethods: Map[Method, Set[Method]]

    Stores for each non-private, non-initializer method the set of methods which override a specific method.

    Stores for each non-private, non-initializer method the set of methods which override a specific method. If the given method is a concrete method, this method is also included in the set of overridingMethods.

    Definition Classes
    ProjectProjectLike
  68. def packages: Set[String]

    Returns the list of all packages that contain at least one class.

    Returns the list of all packages that contain at least one class.

    For example, in case of the JDK the package java does not directly contain any class – only its subclasses. This package is, hence, not returned by this function, but the package java.lang is.

    Note

    This method's result is not cached.

  69. def packagesCount: Int

    Number of packages.

    Number of packages.

    Note

    The result is (re)calculated for each call.

  70. def parForeachClassFile[T](isInterrupted: () ⇒ Boolean = defaultIsInterrupted)(f: (ClassFile) ⇒ T): Unit
  71. def parForeachLibraryClassFile[T](isInterrupted: () ⇒ Boolean = defaultIsInterrupted)(f: (ClassFile) ⇒ T): Unit
  72. def parForeachMethod[T](isInterrupted: () ⇒ Boolean = defaultIsInterrupted)(f: (Method) ⇒ T): Unit

    Iterates over all methods in parallel; actually, the methods belonging to a specific class are analyzed sequentially..

  73. def parForeachMethodWithBody[T](isInterrupted: () ⇒ Boolean = defaultIsInterrupted, parallelizationLevel: Int = NumberOfThreadsForCPUBoundTasks)(f: (MethodInfo[Source]) ⇒ T): Unit

    Iterates over all methods with a body in parallel starting with the largest methods first.

    Iterates over all methods with a body in parallel starting with the largest methods first.

    This method maximizes utilization by allowing each thread to pick the next unanalyzed method as soon as the thread has finished analyzing the previous method. I.e., each thread is not assigned a fixed batch of methods. Additionally, the methods are analyzed ordered by their length (longest first).

  74. def parForeachProjectClassFile[T](isInterrupted: () ⇒ Boolean = defaultIsInterrupted)(f: (ClassFile) ⇒ T): Unit
  75. final val projectClassFilesCount: Int
  76. def projectClassFilesWithSources: Iterable[(ClassFile, Source)]
  77. def projectClassMembersPerClassDistribution: Map[Int, (Int, Set[String])]

    Returns the number of (non-synthetic) fields and methods per class file.

    Returns the number of (non-synthetic) fields and methods per class file. The number of class members of nested classes is also taken into consideration. I.e., the map's key identifies the category and the value is a pair where the first value is the count and the value is the names of the source elements.

    The count can be higher than the set of names of class members due to method overloading.

  78. final val projectFieldsCount: Int
  79. final val projectMethodsCount: Int
  80. def projectMethodsLengthDistribution: Map[Int, Set[Method]]

    Returns the (number of) (non-synthetic) methods per method length (size in length of the method's code array).

  81. def projectPackages: Set[String]

    Returns the set of all project packages that contain at least one class.

    Returns the set of all project packages that contain at least one class.

    For example, in case of the JDK the package java does not directly contain any class – only its subclasses. This package is, hence, not returned by this function, but the package java.lang is.

    Note

    This method's result is not cached.

  82. final val projectType: ProjectType
    Definition Classes
    ProjectProjectLike
  83. def recreate(filterProjectInformation: (Int) ⇒ Boolean = _ ⇒ false): Project[Source]

    Returns a shallow clone of this project with an updated log context and (optionally) filtered ProjectInformations.

    Returns a shallow clone of this project with an updated log context and (optionally) filtered ProjectInformations.

    filterProjectInformation

    Enables filtering of the ProjectInformations that should be kept when a new Project is created.

  84. def resolveAllMethodReferences(declaringClassType: ReferenceType, name: String, descriptor: MethodDescriptor): Set[Method]

    Resolves a method reference to all possible methods.

    Resolves a method reference to all possible methods. I.e., this is identical to resolveMethodReference or resolveInterfaceMethodReference for class and interface types respectively except for the case where there are multiple maximally specific interface methods in which case all of them are returned instead of only a single one.

    declaringClassType

    The type of the object that receives the method call. The type may be a class or interface type.

    returns

    The set of resolved methods; empty if the resolution fails, more than one if resolution finds several maximally specific interface methods - in the latter case it is not possible to call the method on objects of the declaring class type, but only on subclasses overriding the method uniquely.

    Definition Classes
    ProjectLike
  85. def resolveClassMethodReference(receiverType: ObjectType, name: String, descriptor: MethodDescriptor): Result[Method]

    Resolves a symbolic reference to a method defined by a class (not interface) type.

    Resolves a symbolic reference to a method defined by a class (not interface) type.

    returns

    org.opalj.Success(method) if the method was found; Empty if the project is incomplete and the method could not be found; Failure if the method could not be found though the project is seemingly complete. I.e., if Failure is returned the method is not defined by a concrete class and is either a default method defined by an interface or the analyzed code basis is inconsistent.

    Definition Classes
    ProjectLike
  86. final def resolveFieldReference(fieldAccess: FieldAccess): Option[Field]

  87. def resolveFieldReference(declaringClassFile: ClassFile, fieldName: String, fieldType: FieldType): Option[Field]

    Resolves a symbolic reference to a field.

    Resolves a symbolic reference to a field. Basically, the search starts with the given class c and then continues with c's superinterfaces before the search is continued with c's superclass (as prescribed by the JVM specification for the resolution of unresolved symbolic references).

    Resolving a symbolic reference is particularly required to, e.g., get a field's annotations or to get a field's value (if it is static, final and has a constant value).

    declaringClassFile

    The class (or a superclass thereof) that is expected to define the specified field.

    fieldName

    The name of the field.

    fieldType

    The type of the field (the field descriptor).

    Definition Classes
    ProjectLike
    Note

    This implementation does not check for IllegalAccessError. This check needs to be done by the caller. The same applies for the check that the field is non-static if get-/putfield is used and static if a get-/putstatic is used to access the field. In the latter case the JVM would throw a LinkingException. Furthermore, if the field cannot be found, it is the responsibility of the caller to handle that situation.

    ,

    Resolution is final. I.e., either this algorithm has found the defining field or the field is not defined by one of the loaded classes. Searching for the field in subclasses is not meaningful as it is not possible to override fields.

  88. final def resolveFieldReference(declaringClassType: ObjectType, fieldName: String, fieldType: FieldType): Option[Field]

  89. def resolveInterfaceMethodReference(i: INVOKEINTERFACE): Option[Method]

    See #resolveInterfaceMethodReference(declaringClassType:* for details.

  90. def resolveInterfaceMethodReference(declaringClassType: ObjectType, name: String, descriptor: MethodDescriptor): Option[Method]
    Definition Classes
    ProjectLike
  91. def resolveMethodReference(i: INVOKEVIRTUAL): Option[Method]

    See #resolveMethodReference(declaringClassType:* for details.

  92. def resolveMethodReference(declaringClassType: ReferenceType, name: String, descriptor: MethodDescriptor, forceLookupInSuperinterfacesOnFailure: Boolean = false): Option[Method]

    Tries to resolve a method reference as specified by the JVM specification.

    Tries to resolve a method reference as specified by the JVM specification. I.e., the algorithm tries to find the class that actually declares the referenced method. Resolution of signature polymorphic method calls is also supported.

    This method can be used as the basis for the implementation of the semantics of the invokeXXX instructions. However, it does not check whether the resolved method can be accessed by the caller or if it is abstract. Additionally, it is still necessary that the caller makes a distinction between the statically (at compile time) identified declaring class and the dynamic type of the receiver in case of invokevirtual and invokeinterface instructions. I.e., additional processing is necessary on the client side.

    declaringClassType

    The type of the object that receives the method call. The type must be a class type and must not be an interface type. No check w.r.t. a potential IncompatibleClassChangeError is done by this method.

    forceLookupInSuperinterfacesOnFailure

    If true (default: false) the method tries to look up the method in a super interface if it can't find it in the available super classes.

    returns

    The resolved method Some(METHOD) or None. (To get the defining class file use the project's respective method.)

    Definition Classes
    ProjectLike
    Note

    This method just resolves a method reference. Additional checks, such as whether the resolved method is accessible, may be necessary.

  93. def rootPackages: Map[String, String]

    Determines for all packages of this project that contain at least one class the "root" packages and stores the mapping between the package and its root package.

    Determines for all packages of this project that contain at least one class the "root" packages and stores the mapping between the package and its root package.

    For example, let's assume that we have project which has the following packages that contain at least one class:

    • org.opalj
    • org.opalj.ai
    • org.opalj.ai.domain
    • org.apache.commons.io
    • java.lang Then the map will be:
    • org.opalj => org.opalj
    • org.opalj.ai => org.opalj
    • org.opalj.ai.domain => org.opalj
    • org.apache.commons.io => org.apache.commons.io
    • java.lang => java.lang

    In other words the set of rootPackages can then be determined using:

    <Project>.rootPackages().values.toSet
    returns

    a Map which contains for each package name the root package name.

    Note

    This method's result is not cached.

  94. def source(classFile: ClassFile): Option[Source]
  95. def source(objectType: ObjectType): Option[Source]

    Returns the source (for example, a File object or URL object) from which the class file was loaded that defines the given object type, if any.

    Returns the source (for example, a File object or URL object) from which the class file was loaded that defines the given object type, if any.

    objectType

    Some object type.

  96. def sourceElementsCount: Int

    The number of all source elements (fields, methods and class files).

  97. def specialCall(declaringClassType: ObjectType, isInterface: Boolean, name: String, descriptor: MethodDescriptor): Result[Method]

    Returns the instance method/initializer which is called by an invokespecial instruction.

    Returns the instance method/initializer which is called by an invokespecial instruction.

    returns

    One of the following three values:

    • org.opalj.Success (method) if the method was found;
    • Failure if the project is inconsistent; i.e., the target class file is found, but the method cannot be found. Failure is returned on a best effort basis.
    • Empty.
    Definition Classes
    ProjectLike
    Note

    Virtual method call resolution is not necessary; the call target is either a constructor, a private method or a super method/constructor. However, in the first and last case it may be possible that we can't find the method because of an inconsistent or incomplete project.

  98. def specialCall(i: INVOKESPECIAL): Result[Method]
    Definition Classes
    ProjectLike
  99. def staticCall(declaringClassType: ObjectType, isInterface: Boolean, name: String, descriptor: MethodDescriptor): Result[Method]

    Returns the method that will be called by the respective invokestatic call.

    Returns the method that will be called by the respective invokestatic call. (The client may require to perform additional checks such as validating the visibility!)

    returns

    org.opalj.Success (method) if the method was found; Failure if the project is inconsistent. Empty if the method could not be found in the available classes (i.e., the project is incomplete).

    Definition Classes
    ProjectLike
  100. def staticCall(i: INVOKESTATIC): Result[Method]

    Returns the method which will be called by the respective org.opalj.br.instructions.INVOKESTATIC instruction.

    Returns the method which will be called by the respective org.opalj.br.instructions.INVOKESTATIC instruction.

    Definition Classes
    ProjectLike
  101. def statistics: Map[String, Int]

    Some basic statistics about this project.

    Some basic statistics about this project.

    ((Re)Calculated on-demand.)

  102. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  103. def toJavaMap(): HashMap[ObjectType, ClassFile]

    Converts this project abstraction into a standard Java HashMap.

    Converts this project abstraction into a standard Java HashMap.

    Note

    This method is intended to be used by Java projects that want to interact with OPAL.

  104. def toString(): String
    Definition Classes
    Project → AnyRef → Any
  105. def virtualCall(callerPackageName: String, declaringType: ReferenceType, name: String, descriptor: MethodDescriptor): Set[Method]

    Returns the set of methods that may be called by an invokevirtual call, if the receiver type is unknown or effectively encompasses all subtypes it is recommended to use instanceCall.

    Returns the set of methods that may be called by an invokevirtual call, if the receiver type is unknown or effectively encompasses all subtypes it is recommended to use instanceCall.

    Definition Classes
    ProjectLike
    Note

    As in case of instance call, the returned method may have a different descriptor if we have a signature polymorphic call!

  106. def virtualCall(callerPackageName: String, i: INVOKEVIRTUAL): Set[Method]

    Convience method; see virtualCall(callerPackageName:String,declaringType:ReferenceType* for details.

    Convience method; see virtualCall(callerPackageName:String,declaringType:ReferenceType* for details.

    Definition Classes
    ProjectLike
  107. final val virtualMethodsCount: Int
  108. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  109. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  110. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )

Inherited from ProjectLike

Inherited from ClassFileRepository

Inherited from AnyRef

Inherited from Any

Ungrouped