Project

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
val allClassFiles: Iterable[ClassFile]
val allLibraryClassFiles: Iterable[ClassFile]
val allProjectClassFiles: Iterable[ClassFile]
def allSourceElements: Iterable[SourceElement]

Returns a new Iterable over all source elements of the project.
Returns a new Iterable over all source elements of the project. The set of all source elements consists of (in this order): all methods + all fields + all class files.
val analysisMode: AnalysisMode

Definition Classes
Project → ClassFileRepository
final def asInstanceOf[T0]: T0

Definition Classes
Any
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.
def classFile(field: Field): ClassFile

Returns the given field's class file.
Returns the given field's class file. This method is only defined if the field was previously added to this project. (I.e., the class file which defines the field was added.)

Definition Classes
Project → ClassFileRepository
def classFile(method: Method): ClassFile

Returns the given method's class file.
Returns the given method's class file. This method is only defined if the method was previously added to this project. (I.e., the class file which defines the method was added.)

Definition Classes
Project → ClassFileRepository
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. (This method is defined for all ObjectTypes.)

Definition Classes
Project → ClassFileRepository
final val classFilesCount: Int

The number of classes (including inner and annoymous classes as well as interfaces, annotations, etc.) defined in libraries and in the analyzed project.
def classFilesWithSources: Iterable[(ClassFile, Source)]
val classHierarchy: ClassHierarchy
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
val codeSize: Long
implicit val config: Config
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def extend(other: Project[Source]): Project[Source]

Creates a new Project which also includes this as well as the other project's class files.
def extend(projectClassFilesWithSources: Iterable[(ClassFile, Source)]): Project[Source]

Creates a new Project which also includes the given class files.
def fields(): Iterable[Field]

All fields defined by this project as well as the visible fields defined by the libraries.
final val fieldsCount: Int

The number of field defined in libraries and in the analyzed project.
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
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.
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def groupedClassFilesWithMethodsWithBody(groupsCount: Int): Array[Buffer[ClassFile]]
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 and None will be returned.

See also
ProjectInformationKey for further information.
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isLibraryType(objectType: ObjectType): Boolean

Returns true if the given type file belongs to the library part of the project.
Returns true if the given type file belongs to the library part of the project. This is generally the case if no class file was loaded for the given type.
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.
val libraryClassFilesAreInterfacesOnly: Boolean

If true then only the public interface of the methods of the library's classes is available.
val libraryClassFilesCount: Int
def libraryClassFilesWithSources: Iterable[(ClassFile, Source)]
val libraryFieldsCount: Int
val libraryMethodsCount: Int
def libraryPackages: Set[String]

Returns the list of all library packages that contain at least one class.
Returns the list 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.
implicit val logContext: LogContext

The logging context associated with this project.
The logging context associated with this project. Using the logging context after the project is no longer referenced (garbage collected) is not possible.

Definition Classes
Project → ClassFileRepository
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.
def methodNames(objectTypes: Traversable[ObjectType]): Set[String]

The set of all method names of the given types.
def methods(): Iterable[Method]

All methods defined by this project as well as the visible methods defined by the libraries.
final val methodsCount: Int

The number of methods defined in libraries and in the analyzed project.
def methodsWithBody: Iterable[Method]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
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.
def packagesCount: Int

Number of packages.
Number of packages.

Note
The result is (re)calculated for each call.
def parForeachClassFile[T](isInterrupted: () ⇒ Boolean = ...)(f: (ClassFile) ⇒ T): List[Throwable]
def parForeachLibraryClassFile[T](isInterrupted: () ⇒ Boolean = ...)(f: (ClassFile) ⇒ T): List[Throwable]
def parForeachMethodWithBody[T](isInterrupted: () ⇒ Boolean = ...)(f: Function[(Source, ClassFile, Method), T]): List[Throwable]

Iterates over all methods with a body in parallel.
Iterates over all methods with a body in parallel.
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).
def parForeachProjectClassFile[T](isInterrupted: () ⇒ Boolean = ...)(f: (ClassFile) ⇒ T): List[Throwable]
val projectClassFilesCount: Int
def projectClassFilesWithSources: Iterable[(ClassFile, Source)]
def projectClassMembersPerClassDistribution: Map[Int, (Int, Set[String])]

Returns the number of (non-synthetic) source elements per method length (size in length of the method's code array).
Returns the number of (non-synthetic) source elements per method length (size in length of the method's code array). The number of class members of nested classes are also taken into consideration.
val projectFieldsCount: Int
val projectMethodsCount: Int
def projectMethodsLengthDistribution: Map[Int, (Int, Set[Method])]

Returns the (number of) (non-synthetic) methods per method length (size in length of the method's code array).
def projectPackages: Set[String]

Returns the list of all project packages that contain at least one class.
Returns the list 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.
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.
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. (This method is defined for all ObjectTypes.)
def sourceElementsCount: Int

The number of all source elements (fields, methods and class files).
def statistics: Map[String, Int]

Some basic statistics about this project.
Some basic statistics about this project.
((Re)Calculated on-demand.)
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
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.
def toString(): String

Definition Classes
Project → AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: object Project | package analyses

class Project[Source] extends ClassFileRepository

Thread Safety

Prototyping Analyses/Querying Projects

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val allClassFiles: Iterable[ClassFile]

val allLibraryClassFiles: Iterable[ClassFile]

val allProjectClassFiles: Iterable[ClassFile]

def allSourceElements: Iterable[SourceElement]

val analysisMode: AnalysisMode

final def asInstanceOf[T0]: T0

def availableProjectInformation: List[AnyRef]

def classFile(field: Field): ClassFile

def classFile(method: Method): ClassFile

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

final val classFilesCount: Int

def classFilesWithSources: Iterable[(ClassFile, Source)]

val classHierarchy: ClassHierarchy

def clone(): AnyRef

val codeSize: Long

implicit val config: Config

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def extend(other: Project[Source]): Project[Source]

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

def fields(): Iterable[Field]

final val fieldsCount: Int

def finalize(): Unit

def get[T <: AnyRef](pik: ProjectInformationKey[T]): T

final def getClass(): Class[_]

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

def has[T <: AnyRef](pik: ProjectInformationKey[T]): Option[T]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def isLibraryType(objectType: ObjectType): Boolean

def isLibraryType(classFile: ClassFile): Boolean

val libraryClassFilesAreInterfacesOnly: Boolean

val libraryClassFilesCount: Int

def libraryClassFilesWithSources: Iterable[(ClassFile, Source)]

val libraryFieldsCount: Int

val libraryMethodsCount: Int

def libraryPackages: Set[String]

implicit val logContext: LogContext

def lookupClassFiles(objectTypes: Traversable[ObjectType])(classFileFilter: (ClassFile) ⇒ Boolean): Traversable[ClassFile]

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

def methods(): Iterable[Method]

final val methodsCount: Int

def methodsWithBody: Iterable[Method]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def packages: Set[String]

def packagesCount: Int

def parForeachClassFile[T](isInterrupted: () ⇒ Boolean = ...)(f: (ClassFile) ⇒ T): List[Throwable]

def parForeachLibraryClassFile[T](isInterrupted: () ⇒ Boolean = ...)(f: (ClassFile) ⇒ T): List[Throwable]

def parForeachMethodWithBody[T](isInterrupted: () ⇒ Boolean = ...)(f: Function[(Source, ClassFile, Method), T]): List[Throwable]

def parForeachProjectClassFile[T](isInterrupted: () ⇒ Boolean = ...)(f: (ClassFile) ⇒ T): List[Throwable]

val projectClassFilesCount: Int

def projectClassFilesWithSources: Iterable[(ClassFile, Source)]

def projectClassMembersPerClassDistribution: Map[Int, (Int, Set[String])]

val projectFieldsCount: Int

val projectMethodsCount: Int

def projectMethodsLengthDistribution: Map[Int, (Int, Set[Method])]

def projectPackages: Set[String]

def rootPackages: Map[String, String]

def source(objectType: ObjectType): Option[Source]

def sourceElementsCount: Int

def statistics: Map[String, Int]

final def synchronized[T0](arg0: ⇒ T0): T0

def toJavaMap(): HashMap[ObjectType, ClassFile]

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from ClassFileRepository

Inherited from AnyRef