br

Type Members

1. case class Annotation(annotationType: FieldType, elementValuePairs: ElementValuePairs = IndexedSeq.empty) extends Product with Serializable

   

   An annotation of a class, field, method or method parameter.

   An annotation of a class, field, method or method parameter.

   Annotations are associated with a class, field, or method using the attribute org.opalj.br.RuntimeInvisibleAnnotationTable or org.opalj.br.RuntimeVisibleAnnotationTable.

   Annotations are associated with a method parameter using the attribute org.opalj.br.RuntimeInvisibleParameterAnnotationTable or a org.opalj.br.RuntimeVisibleParameterAnnotationTable.

2. trait AnnotationTable extends Attribute

   

   The runtime (in)visible annotations of a class, method, or field.

   The runtime (in)visible annotations of a class, method, or field.

   Note

   At the JVM level, repeating annotations (as supported by Java 8) (http://docs.oracle.com/javase/tutorial/java/annotations/repeating.html) have no explicit support.

3. case class AnnotationValue(annotation: Annotation) extends ElementValue with Product with Serializable

   

4. type Annotations = IndexedSeq[Annotation]

   

5. final case class AppendFrame(frameType: Int, offsetDelta: Int, verificationTypeInfoLocals: VerificationTypeInfoLocals) extends StackMapFrame with Product with Serializable

   

6. final class ArrayType extends ReferenceType

   

   Represents an array type.

   Represents an array type.

   Comparing ArrayTypes

   To facilitate comparisons of (array) types, each array type is represented at any given time, by exactly one instance of ArrayType.

   General Information

   From the JVM specification

   An array type consists of a component type with a single dimension (whose length is not given by the type). The component type of an array type may itself be an array type. If, starting from any array type, one considers its component type, and then (if that is also an array type) the component type of that type, and so on, eventually one must reach a component type that is not an array type; this is called the element type of the array type. The element type of an array type is necessarily either a primitive type, or a class type, or an interface type.

7. case class ArrayTypeSignature(typeSignature: TypeSignature) extends FieldTypeSignature with Product with Serializable

   
   See also

   For matching signatures see Signature.

8. case class ArrayValue(values: IndexedSeq[ElementValue]) extends ElementValue with Product with Serializable

   

9. trait Attribute extends AnyRef

   

   A class file attribute.

   A class file attribute.

   Note

   Some class file attributes are skipped or resolved while loading the class file and hence, are no longer represented at runtime.

10. type Attributes = Seq[Attribute]

    

11. sealed abstract class BaseType extends FieldType with TypeSignature

    

12. sealed trait BaseTypeElementValue extends ElementValue

    

    Common super trait of all element values with a primitive base type.

13. sealed abstract class BooleanType extends BaseType

    

    The type of boolean values (true=1, false=0).

    The type of boolean values (true=1, false=0).

    Though the JVM internally uses an int value to store a boolean value the VM offers no special further support for handling booleans. In particular the conversion of some "byte|short|char|int" value to an int value is not directly supported.

14. case class BooleanValue(value: Boolean) extends BaseTypeElementValue with Product with Serializable

    

15. trait BootstrapArgument extends AnyRef

    

    A marker trait to identify those constant pool values that can be arguments of boot strap methods.

16. type BootstrapArguments = IndexedSeq[BootstrapArgument]

    

17. case class BootstrapMethod(methodHandle: MethodHandle, bootstrapArguments: BootstrapArguments) extends Product with Serializable

    

    Java 7's 'BootstrapMethod'.

18. case class BootstrapMethodTable(methods: BootstrapMethods) extends Attribute with Product with Serializable

    

    Java 7's BootstrapMethods_attribute.

19. type BootstrapMethods = IndexedSeq[BootstrapMethod]

    

20. sealed abstract class ByteType extends IntLikeType

    

21. case class ByteValue(value: Byte) extends BaseTypeElementValue with Product with Serializable

    

22. sealed abstract class CharType extends IntLikeType

    

23. case class CharValue(value: Char) extends BaseTypeElementValue with Product with Serializable

    

24. final case class ChopFrame(frameType: Int, offsetDelta: Int) extends StackMapFrame with Product with Serializable

    

25. final class ClassFile extends ConcreteSourceElement

    

    Represents a single class file which either defines a class type or an interface type.

    Represents a single class file which either defines a class type or an interface type. (Annotation types are also interface types and Enums are class types.)

    Note

    Equality of ClassFile objects is reference based and a class file's hash code is the same as thisType's hash code.

26. trait ClassFileRepository extends AnyRef

    

    Enables the lookup of ClassFiles.

27. class ClassHierarchy extends AnyRef

    

    Represents a project's class hierarchy.

    Represents a project's class hierarchy. The class hierarchy only contains information about those classes that were explicitly added to it except of java.lang.Object; the type java.lang.Object is always part of the class hierarchy.

    Thread safety

    This class is effectively immutable. Hence, concurrent access to the class hierarchy is supported.

    Note

    Unless explicitly documented, it is an error to pass an instance of ObjectType to any method if the ObjectType was not previously added. If in doubt, first check if the type is known (isKnown/ifKnown).

28. trait ClassMember extends ConcreteSourceElement

    

    Abstractions over the common properties of class members (Methods and Fields).

29. case class ClassSignature(formalTypeParameters: List[FormalTypeParameter], superClassSignature: ClassTypeSignature, superInterfacesSignature: List[ClassTypeSignature]) extends Signature with Product with Serializable

    
    See also

    For matching signatures see Signature.

30. case class ClassTypeSignature(packageIdentifier: Option[String], simpleClassTypeSignature: SimpleClassTypeSignature, classTypeSignatureSuffix: List[SimpleClassTypeSignature]) extends FieldTypeSignature with ThrowsSignature with Product with Serializable

    
    See also

    For matching signatures see Signature.

31. case class ClassValue(value: Type) extends ElementValue with Product with Serializable

    

32. final class Code extends Attribute with CommonAttributes with InstructionsContainer

    

    Representation of a method's code attribute, that is, representation of a method's implementation.

33. case class CodeAnalysisFailedException(message: String, code: Code, pc: PC) extends RuntimeException with Product with Serializable

    

    Exception that is thrown when an analysis of a method's implementation has failed.

    Exception that is thrown when an analysis of a method's implementation has failed.

    message

    The message that describes the reason.

    code

    The code block for which the analysis failed.

    pc

    The program counter of the last instruction that was tried to analyze.

34. trait CommonAttributes extends AnyRef

    

    Defines methods to return common attributes from the attributes table of ClassFile, Field, Method and Code declarations.

35. trait CommonSourceElementAttributes extends CommonAttributes

    

    Defines methods to return common attributes from the attributes table of ClassFile, Field and Method declarations.

36. case class CompactLineNumberTable(lineNumbers: Array[Byte]) extends LineNumberTable with Product with Serializable

    

    A method's line number table.

37. sealed abstract class ComputationalType extends AnyRef

    

    The computational type of a value on the operand stack.

    The computational type of a value on the operand stack.

    (cf. JVM Spec. 2.11.1 Types and the Java Virtual Machine).

38. sealed abstract class ComputationalTypeCategory extends AnyRef

    

    The computational type category of a value on the operand stack.

    The computational type category of a value on the operand stack.

    (cf. JVM Spec. 2.11.1 Types and the Java Virtual Machine).

39. trait ConcreteSourceElement extends SourceElement

    

    We treat as a source element every entity that can be referred to by other class files.

40. final case class ConstantClass(value: ReferenceType) extends ConstantValue[ReferenceType] with Product with Serializable

    

    Represents a class or interface.

    Represents a class or interface.

    ConstantClass is, e.g., used by anewarray and multianewarray instructions. A ConstantClass value is never a Field value. I.e., it is never used to set the value of a static field.

41. final case class ConstantDouble(value: Double) extends ConstantFieldValue[Double] with Product with Serializable

    

42. sealed trait ConstantFieldValue[T] extends Attribute with ConstantValue[T]

    

    A representation of the constant value of a field.

43. final case class ConstantFloat(value: Float) extends ConstantFieldValue[Float] with Product with Serializable

    

44. final case class ConstantInteger(value: Int) extends ConstantFieldValue[Int] with Product with Serializable

    

45. final case class ConstantLong(value: Long) extends ConstantFieldValue[Long] with Product with Serializable

    

46. final case class ConstantString(value: String) extends ConstantFieldValue[String] with Product with Serializable

    

47. trait ConstantValue[T] extends BootstrapArgument

    

    Represents constant values; i.e., values pushed onto the stack by the ldc(2)(_w) instructions or type information required by the instructions to create arrays.

    Represents constant values; i.e., values pushed onto the stack by the ldc(2)(_w) instructions or type information required by the instructions to create arrays.

    Note

    A MethodHandle or MethodType (i.e., a MethodDescriptor) is also a ConstantValue.

48. sealed trait ContravariantIndicator extends VarianceIndicator

    

    A declaration such as <? super Entry> is represented in class file signatures by the ContravariantIndicator ("? super") and a FieldTypeSignature.

    A declaration such as <? super Entry> is represented in class file signatures by the ContravariantIndicator ("? super") and a FieldTypeSignature.

    See also

    For matching signatures see Signature.

49. sealed trait CovariantIndicator extends VarianceIndicator

    

    If you have a declaration such as <? extends Entry> then the "? extends" part is represented by the CovariantIndicator.

    If you have a declaration such as <? extends Entry> then the "? extends" part is represented by the CovariantIndicator.

    See also

    For matching signatures see Signature.

50. sealed abstract class DoubleType extends NumericType

    

51. case class DoubleValue(value: Double) extends BaseTypeElementValue with Product with Serializable

    

52. sealed trait ElementValue extends Attribute

    

    An element value represents an annotation's value or an annonation's default value; depending on the context in which it is used.

53. case class ElementValuePair(name: String, value: ElementValue) extends Product with Serializable

    

    An annotation's name-value pair.

54. type ElementValuePairs = IndexedSeq[ElementValuePair]

    

55. case class EnclosingMethod(clazz: ObjectType, name: Option[String], descriptor: Option[MethodDescriptor]) extends Attribute with Product with Serializable

    

    The optional enclosing method attribute of a class.

    The optional enclosing method attribute of a class.

    name

    The name of the enclosing method.

    descriptor

    The method descriptor of the enclosing method.

56. case class EnumValue(enumType: ObjectType, constName: String) extends ElementValue with Product with Serializable

    

57. case class ExceptionHandler(startPC: Int, endPC: Int, handlerPC: Int, catchType: Option[ObjectType]) extends Product with Serializable

    

    An entry in the exceptions table of a org.opalj.br.Code block.

    An entry in the exceptions table of a org.opalj.br.Code block.

    startPC

    A valid index into the code array. It points to the first instruction in the "try-block" (inclusive).

    endPC

    An index into the code array that points to the instruction after the "try-block" (exclusive).

    handlerPC

    Points to the first instruction of the exception handler.

    catchType

    The type of the exception that is catched. None in case of a finally block.

58. type ExceptionHandlers = IndexedSeq[ExceptionHandler]

    

59. case class ExceptionTable(exceptions: Exceptions) extends Attribute with Product with Serializable

    

    Attribute in a method's attributes table that declares the (checked) exceptions that may be thrown by the method.

60. type Exceptions = Seq[ObjectType]

    

61. final class Field extends ClassMember with Ordered[Field]

    

    Represents a single field declaration/definition.

    Represents a single field declaration/definition.

    Note

    Identity (w.r.t. equals/hashCode) is intentionally by reference (default behavior).

    ,

    Fields have – by default – no link to their defining ClassFile. However, if a analyses.Project is available then it is possible to get a Field's ClassFile by using Project's classFile(Field) method.

62. sealed trait FieldAccessMethodHandle extends MethodHandle

    

63. case class FieldIdentifier(declaringObjectType: ObjectType, fieldName: String) extends StructureIdentifier with Product with Serializable

    

64. sealed trait FieldReadAccessMethodHandle extends FieldAccessMethodHandle

    

65. sealed abstract class FieldType extends Type

    

    Supertype of all types except VoidType.

66. trait FieldTypeSignature extends Signature with TypeSignature

    
    See also

    For matching signatures see Signature.

67. sealed trait FieldWriteAccessMethodHandle extends FieldAccessMethodHandle

    

68. type Fields = IndexedSeq[Field]

    

69. sealed abstract class FloatType extends NumericType

    

70. case class FloatValue(value: Float) extends BaseTypeElementValue with Product with Serializable

    

71. case class FormalTypeParameter(identifier: String, classBound: Option[FieldTypeSignature], interfaceBound: List[FieldTypeSignature]) extends Product with Serializable

    
    See also

    For matching signatures see Signature.

72. final case class FullFrame(frameType: Int, offsetDelta: Int, verificationTypeInfoLocals: VerificationTypeInfoLocals, verificationTypeInfoStack: VerificationTypeInfoStack) extends StackMapFrame with Product with Serializable

    

73. case class GetFieldMethodHandle(declaringClassType: ObjectType, name: String, fieldType: FieldType) extends FieldReadAccessMethodHandle with Product with Serializable

    

74. case class GetStaticMethodHandle(declaringClassType: ObjectType, name: String, fieldType: FieldType) extends FieldReadAccessMethodHandle with Product with Serializable

    

75. case class InnerClass(innerClassType: ObjectType, outerClassType: Option[ObjectType], innerName: Option[String], innerClassAccessFlags: Int) extends Product with Serializable

    

76. case class InnerClassTable(innerClasses: InnerClasses) extends Attribute with Product with Serializable

    

    Attribute in a class' attribute table the encodes information about inner classes.

77. type InnerClasses = IndexedSeq[InnerClass]

    

78. type Instructions = Array[Instruction]

    

79. trait InstructionsContainer extends AnyRef

    

    Common interface of all elements that have (at most one) sequence of instructions.

80. sealed abstract class IntLikeType extends NumericType

    

    An IntLikeType is every type (byte, char, short and int) that uses a primtive int to store the current value and which has explicit support in the JVM.

    An IntLikeType is every type (byte, char, short and int) that uses a primtive int to store the current value and which has explicit support in the JVM.

    Note

    Boolean values are (at least conceptually) also stored in ints. However, the JVM has basically no explicit support for booleans (e.g., a conversion of an int value to a boolean is not directly supported).

81. case class IntValue(value: Int) extends BaseTypeElementValue with Product with Serializable

    

82. sealed abstract class IntegerType extends IntLikeType

    

83. case class InvokeInterfaceMethodHandle(receiverType: ReferenceType, name: String, methodDescriptor: MethodDescriptor) extends MethodCallMethodHandle with Product with Serializable

    

84. case class InvokeSpecialMethodHandle(receiverType: ReferenceType, name: String, methodDescriptor: MethodDescriptor) extends MethodCallMethodHandle with Product with Serializable

    

85. case class InvokeStaticMethodHandle(receiverType: ReferenceType, name: String, methodDescriptor: MethodDescriptor) extends MethodCallMethodHandle with Product with Serializable

    

86. case class InvokeVirtualMethodHandle(receiverType: ReferenceType, name: String, methodDescriptor: MethodDescriptor) extends MethodCallMethodHandle with Product with Serializable

    

87. case class LineNumber(startPC: Int, lineNumber: Int) extends Product with Serializable

    

    An entry in a line number table.

88. trait LineNumberTable extends Attribute

    

    A method's line number table.

89. type LineNumbers = Seq[LineNumber]

    

90. case class LocalVariable(startPC: PC, length: Int, name: String, fieldType: FieldType, index: Int) extends Product with Serializable

    

    An entry in a local variable table.

91. case class LocalVariableTable(localVariables: LocalVariables) extends Attribute with Product with Serializable

    

    Representation of the local variable table.

92. case class LocalVariableType(startPC: Int, length: Int, name: String, signature: FieldTypeSignature, index: Int) extends Product with Serializable

    

93. case class LocalVariableTypeTable(localVariableTypes: LocalVariableTypes) extends Attribute with Product with Serializable

    

    Representation of the local variable type table.

94. type LocalVariableTypes = IndexedSeq[LocalVariableType]

    

95. type LocalVariables = IndexedSeq[LocalVariable]

    

96. case class LocalvarTableEntry(start_pc: Int, length: Int, local_variable_table_index: Int) extends Product with Serializable

    

97. sealed abstract class LongType extends NumericType

    

98. case class LongValue(value: Long) extends BaseTypeElementValue with Product with Serializable

    

99. final class Method extends ClassMember with Ordered[Method] with InstructionsContainer

    

    Represents a single method.

    Represents a single method.

    Method objects are constructed using the companion object's factory methods.

    Note

    Equality of methods is – by purpose – reference based.

    ,

    Methods have – by default – no link to their defining ClassFile. However, if a analyses.Project is available then it is possible to get a Method's ClassFile by using Project's classFile(Method) method.

100. trait MethodCallMethodHandle extends MethodHandle

     

101. sealed abstract class MethodDescriptor extends ConstantValue[MethodDescriptor] with Ordered[MethodDescriptor]

     

     A method descriptor represents the parameters that the method takes and the value that it returns.

     A method descriptor represents the parameters that the method takes and the value that it returns.

     Note

     The equals(Any):Boolean method takes the number of parameters and types into account. I.e., two method descriptor objects are equal if they have the same number of parameters and each parameter has the same Type.

102. sealed trait MethodHandle extends ConstantValue[MethodHandle]

     

     A method handle.

103. case class MethodIdentifier(declaringReferenceType: ReferenceType, methodName: String, methodDescriptor: MethodDescriptor) extends StructureIdentifier with Product with Serializable

     

104. case class MethodParameter(name: String, access_flags: Int) extends Product with Serializable

     

     The description of a method parameter.

105. case class MethodParameterTable(parameters: MethodParameters) extends Attribute with Product with Serializable

     

     Representation of a method's information about the method parameters.

106. type MethodParameters = IndexedSeq[MethodParameter]

     

107. case class MethodSignature(name: String, descriptor: MethodDescriptor) extends Product with Serializable

     

     Represents a method signature which consists of the name and descriptor of a method; the signatures of all methods of a class file has to be different.

108. case class MethodTypeSignature(formalTypeParameters: List[FormalTypeParameter], parametersTypeSignatures: List[TypeSignature], returnTypeSignature: ReturnTypeSignature, throwsSignature: List[ThrowsSignature]) extends Signature with Product with Serializable

     
     See also

     For matching signatures see Signature.

109. type Methods = IndexedSeq[Method]

     

110. case class NewInvokeSpecialMethodHandle(receiverType: ReferenceType, name: String, methodDescriptor: MethodDescriptor) extends MethodCallMethodHandle with Product with Serializable

     

111. trait NoSourceElementsVisitor extends SourceElementsVisitor[Unit]

     

     Simple implementation of the SourceElementsVisitor trait where all methods do nothing.

112. sealed abstract class NumericType extends BaseType

     

113. final class ObjectType extends ReferenceType

     

     Represents an ObjectType.

114. case class ObjectVariableInfo(clazz: ReferenceType) extends VerificationTypeInfo with Product with Serializable

     

115. type Opcode = Int

     

116. type PC = Int

     

     A program counter identifies an instruction in a code array.

     A program counter identifies an instruction in a code array.

     A program counter is a value in the range [0/*UShort.min*/, 65535/*UShort.max*/].

     Note

     This type alias serves comprehension purposes.

117. type PCs = UShortSet

     

     A collection of program counters using a UShortSet as its backing collection.

     A collection of program counters using a UShortSet as its backing collection.

     Using PCs is in particular well suited for small(er) collections.

     Note

     This type alias serves comprehension purposes.

118. trait ParameterAnnotationTable extends Attribute

     

     Parameter annotations.

119. type ParameterAnnotations = IndexedSeq[Annotations]

     

120. case class ProperTypeArgument(varianceIndicator: Option[VarianceIndicator], fieldTypeSignature: FieldTypeSignature) extends TypeArgument with Product with Serializable

     
     See also

     For matching signatures see Signature.

121. case class PutFieldMethodHandle(declaringClassType: ObjectType, name: String, fieldType: FieldType) extends FieldWriteAccessMethodHandle with Product with Serializable

     

122. case class PutStaticMethodHandle(declaringClassType: ObjectType, name: String, fieldType: FieldType) extends FieldWriteAccessMethodHandle with Product with Serializable

     

123. sealed abstract class ReferenceType extends FieldType

     

124. trait ReturnTypeSignature extends SignatureElement

     

125. case class RuntimeInvisibleAnnotationTable(annotations: Annotations) extends AnnotationTable with Product with Serializable

     

     The runtime invisible class, method, or field annotations.

126. case class RuntimeInvisibleParameterAnnotationTable(parameterAnnotations: ParameterAnnotations) extends ParameterAnnotationTable with Product with Serializable

     

     Parameter annotations.

127. case class RuntimeInvisibleTypeAnnotationTable(typeAnnotations: TypeAnnotations) extends TypeAnnotationTable with Product with Serializable

     

     The runtime invisible type annotations.

128. case class RuntimeVisibleAnnotationTable(annotations: Annotations) extends AnnotationTable with Product with Serializable

     

     A class, method, or field annotation.

129. case class RuntimeVisibleParameterAnnotationTable(parameterAnnotations: ParameterAnnotations) extends ParameterAnnotationTable with Product with Serializable

     

     Parameter annotations.

130. case class RuntimeVisibleTypeAnnotationTable(typeAnnotations: TypeAnnotations) extends TypeAnnotationTable with Product with Serializable

     

     A runtime visible type annotation.

131. final case class SameFrame(frameType: Int) extends StackMapFrame with Product with Serializable

     

132. final case class SameFrameExtended(frameType: Int, offsetDelta: Int) extends StackMapFrame with Product with Serializable

     

133. final case class SameLocals1StackItemFrame(frameType: Int, verificationTypeInfoStackItem: br.VerificationTypeInfo) extends StackMapFrame with Product with Serializable

     

134. final case class SameLocals1StackItemFrameExtended(frameType: Int, offsetDelta: Int, verificationTypeInfoStackItem: br.VerificationTypeInfo) extends StackMapFrame with Product with Serializable

     

135. sealed abstract class ShortType extends IntLikeType

     

136. case class ShortValue(value: Short) extends BaseTypeElementValue with Product with Serializable

     

137. sealed trait Signature extends SignatureElement with Attribute

     

     An attribute-level signature as defined in the JVM specification.

     An attribute-level signature as defined in the JVM specification.

     To match Signature objects the predefined matchers/extractors can be used. * @example

     Example 1

     interface Processor extends Function<Object, Void> { /*empty*/ }

     ClassSignature: Ljava/lang/Object;Ljava/util/function/Function<Ljava/lang/Object;Ljava/lang/Void;>;

     ClassSignature(
       typeParameters=List(),
       superClass=ClassTypeSignature(Some(java/lang/),SimpleClassTypeSignature(Object,List()),List()),
       superInterfaces=List(
           ClassTypeSignature(
               Some(java/util/function/),
               SimpleClassTypeSignature(Function,
                     List(ProperTypeArgument(
                            None,
                            ClassTypeSignature(
                               Some(java/lang/),
                               SimpleClassTypeSignature(Object,List()),
                               List())),
                        ProperTypeArgument(
                           None,
                           ClassTypeSignature(
                               Some(java/lang/),
                               SimpleClassTypeSignature(Void,List()),
                               List())))),
               List())))

     Example 2

     interface Col<C> { /*empty*/ }

     ClassSignature: <C:Ljava/lang/Object;>Ljava/lang/Object;

     ClassSignature(
         typeParameters=
             List(
                 FormalTypeParameter(
                     C,
                     Some(ClassTypeSignature(
                             Some(java/lang/),SimpleClassTypeSignature(Object,List()),List())),
                     List())),
          superClass=ClassTypeSignature(
                 Some(java/lang/),SimpleClassTypeSignature(Object,List()),List()),
          superInterfaces=List())

     Example 3

     interface ColObject extends Col<Object> { /*empty*/ }

     ClassSignature: Ljava/lang/Object;LCol<Ljava/lang/Object;>;

     ClassSignature(
         typeParameters=List(),
         superClass=ClassTypeSignature(Some(java/lang/),SimpleClassTypeSignature(Object,List()),List()),
         superInterfaces=List(
                 ClassTypeSignature(
                     None,
                     SimpleClassTypeSignature(
                         Col,
                         List(ProperTypeArgument(
                                 variance=None,
                                 signature=ClassTypeSignature(Some(java/lang/),SimpleClassTypeSignature(Object,List()),List()))
                      )),
                      List())))

     Example 4

     interface ColError<E extends Error> extends Col<E>{/*empty*/}

     ClassSignature: <E:Ljava/lang/Error;>Ljava/lang/Object;LCol<TE;>;

     ClassSignature(
         typeParameters=List(
                 FormalTypeParameter(
                     E,
                     Some(ClassTypeSignature(Some(java/lang/),SimpleClassTypeSignature(Error,List()),List())),List())),
         superClass=ClassTypeSignature(Some(java/lang/),SimpleClassTypeSignature(Object,List()),List()),
         superInterfaces=List(
                 ClassTypeSignature(
                     None,
                     SimpleClassTypeSignature(
                         Col,
                         List(ProperTypeArgument(variance=None,signature=TypeVariableSignature(E)))),
                     List())))

     Example 5

     class Use {
       // The following fields all have "ClassTypeSignatures"
       Col<?> ce = null; // Signature: LCol<*>;
       Col<Object> co = null; // Signature: LCol;
       Col<? super Serializable> cs = null; // Signature: LCol<-Ljava/io/Serializable;>;
       Col<? extends Comparable<?>> cc = null; // Signature: LCol<+Ljava/lang/Comparable<*>;>;
     
       MyCol<java.util.List<Object>> mco = new MyCol<>();
       MyCol<java.util.List<Object>>.MyInnerCol<Comparable<java.util.List<Object>>> mico = this.mco.new MyInnerCol<Comparable<java.util.List<Object>>>();
       // Signature: LMyCol;>.MyInnerCol;>;>;
     }

     AST of mico:

     ClassSignature(
         typeParameters=List(),
         superClass=ClassTypeSignature(
                 None,
                 SimpleClassTypeSignature(
                     MyCol,
                     List(ProperTypeArgument(
                             variance=None,
                             signature=ClassTypeSignature(
                                     Some(java/util/),
                                     SimpleClassTypeSignature(
                                         List,
                                         List(ProperTypeArgument(
                                                 variance=None,
                                                 signature=ClassTypeSignature(
                                                         Some(java/lang/),
                                                         SimpleClassTypeSignature(Object,List()),
                                                         List())))),
                                      List())))),
                 /*suffic=*/List(SimpleClassTypeSignature(
                         MyInnerCol,
                         List(ProperTypeArgument(
                                 variance=None,
                                 signature=ClassTypeSignature(
                                     Some(java/lang/),
                                     SimpleClassTypeSignature(
                                         Comparable,
                                         List(ProperTypeArgument(
                                                 variance=None,
                                                 signature=ClassTypeSignature(
                                                         Some(java/util/),
                                                         SimpleClassTypeSignature(
                                                             List,
                                                             List(ProperTypeArgument(
                                                                     variance=None,
                                                                     signature=ClassTypeSignature(
                                                                             Some(java/lang/),
                                                                             SimpleClassTypeSignature(Object,List()),
                                                                             List())))),
                                                         List())))),
                                     List())))))),
         superInterfaces=List())

     Matching Signatures

     Scala REPL:

     val SignatureParser = org.opalj.br.reader.SignatureParser
     val GenericType = org.opalj.br.GenericType
     val SimpleGenericType = org.opalj.br.SimpleGenericType
     val BasicClassTypeSignature = org.opalj.br.BasicClassTypeSignature
     
     SignatureParser.parseClassSignature("Ljava/lang/Object;LCol;").superInterfacesSignature.head match { case BasicClassTypeSignature(ot) => ot.toJava; case _ => null}
     // res: String = Col
     
     SignatureParser.parseClassSignature("Ljava/lang/Object;LCol;").superInterfacesSignature.head match { case SimpleGenericType(bt,gt) => bt.toJava+"<"+gt.toJava+">"; case _ => null}
     //res11: String = null
     
     scala> SignatureParser.parseFieldTypeSignature("LCol;") match { case SimpleGenericType(bt,ta) => bt.toJava+"<"+ta+">"; case _ => null}
     res1: String = Col<ObjectType(java/lang/Object)>
     
     scala> SignatureParser.parseFieldTypeSignature("LCol;") match { case GenericType(bt,ta) => bt.toJava+"<"+ta+">"; case _ => null}
     res2: String = Col<List(ProperTypeArgument(variance=None,signature=ClassTypeSignature(Some(java/lang/),SimpleClassTypeSignature(Object,List()),List())))>

138. trait SignatureElement extends AnyRef

     

     An element of a Signature used to encode generic type information.

139. trait SignatureVisitor[T] extends AnyRef

     

     Implements a visitor for type signatures.

140. case class SimpleClassTypeSignature(simpleName: String, typeArguments: List[TypeArgument]) extends Product with Serializable

     
     See also

     For matching signatures see Signature.

141. case class SourceDebugExtension(debug_extension: Array[Byte]) extends Attribute with Product with Serializable

     

     Attribute to associate additional debug information with a class.

     Attribute to associate additional debug information with a class. The source debug extension attribute is an optional attribute of a class declaration (org.opalj.br.ClassFile).

142. trait SourceElement extends CommonSourceElementAttributes

     

     We treat as a source element every entity that can be referred to by other class files.

143. type SourceElementID = Int

     

144. trait SourceElementsVisitor[T] extends AnyRef

     

     Classes that traverse a class file can extend this trait to facilitate reporting the traversed source file elements.

145. case class SourceFile(sourceFile: String) extends Attribute with Product with Serializable

     

     The source file attribute is an optional attribute in the attributes table of org.opalj.br.ClassFile objects.

     The source file attribute is an optional attribute in the attributes table of org.opalj.br.ClassFile objects.

     sourceFile

     The name of the source file from which this class file was compiled; it will not contain any path information.

146. sealed trait StackMapFrame extends AnyRef

     

     Part of the Java 6 stack map table attribute.

147. type StackMapFrames = IndexedSeq[StackMapFrame]

     

148. case class StackMapTable(stackMapFrames: StackMapFrames) extends Attribute with Product with Serializable

     

     Java 6's stack map table attribute.

149. case class StringValue(value: String) extends ElementValue with Product with Serializable

     

150. trait StructureIdentifier extends AnyRef

     

     Uniquely identifies a specific element that can (by definition) only exist once in a project.

     Uniquely identifies a specific element that can (by definition) only exist once in a project. For example, in the context of OPAL a type declaration is unique or the combination of a type declaration and a field name or the combination of a type declaration, method name and method descriptor.

151. case class TAOfCastExpression(offset: Int, type_argument_index: Int) extends TypeAnnotationTarget with Product with Serializable

     

152. case class TAOfCatch(exception_table_index: Int) extends TypeAnnotationTarget with Product with Serializable

     

153. case class TAOfConstructorInMethodReferenceExpression(offset: Int, type_argument_index: Int) extends TypeAnnotationTarget with Product with Serializable

     

154. case class TAOfConstructorInvocation(offset: Int, type_argument_index: Int) extends TypeAnnotationTarget with Product with Serializable

     

155. case class TAOfFormalParameter(formal_parameter_index: Int) extends TypeAnnotationTarget with Product with Serializable

     

156. case class TAOfInstanceOf(offset: Int) extends TypeAnnotationTarget with Product with Serializable

     

157. case class TAOfLocalvarDecl(localVarTable: IndexedSeq[LocalvarTableEntry]) extends TypeAnnotationTarget with Product with Serializable

     

158. case class TAOfMethodInMethodReferenceExpression(offset: Int, type_argument_index: Int) extends TypeAnnotationTarget with Product with Serializable

     

159. case class TAOfMethodInvocation(offset: Int, type_argument_index: Int) extends TypeAnnotationTarget with Product with Serializable

     

160. case class TAOfMethodReferenceExpressionIdentifier(offset: Int) extends TypeAnnotationTarget with Product with Serializable

     

161. case class TAOfMethodReferenceExpressionNew(offset: Int) extends TypeAnnotationTarget with Product with Serializable

     

162. case class TAOfNew(offset: Int) extends TypeAnnotationTarget with Product with Serializable

     

163. case class TAOfParameterDeclarationOfClassOrInterface(type_parameter_index: Int) extends TypeAnnotationTarget with Product with Serializable

     

164. case class TAOfParameterDeclarationOfMethodOrConstructor(type_parameter_index: Int) extends TypeAnnotationTarget with Product with Serializable

     

165. case class TAOfResourcevarDecl(localVarTable: IndexedSeq[LocalvarTableEntry]) extends TypeAnnotationTarget with Product with Serializable

     

166. case class TAOfSupertype(supertype_index: Int) extends TypeAnnotationTarget with Product with Serializable

     

167. case class TAOfThrows(throws_type_index: Int) extends TypeAnnotationTarget with Product with Serializable

     

168. case class TAOfTypeBoundOfParameterDeclarationOfClassOrInterface(type_parameter_index: Int, bound_index: Int) extends TypeAnnotationTarget with Product with Serializable

     

169. case class TAOfTypeBoundOfParameterDeclarationOfMethodOrConstructor(type_parameter_index: Int, bound_index: Int) extends TypeAnnotationTarget with Product with Serializable

     

170. case class TAOnNestedType(path: IndexedSeq[TypeAnnotationPathElement]) extends TypeAnnotationPath with Product with Serializable

     

171. case class TAOnTypeArgument(type_argument_index: Int) extends TypeAnnotationPathElement with Product with Serializable

     

172. sealed trait ThrowsSignature extends SignatureElement

     

173. trait TraversingVisitor extends SignatureVisitor[Unit]

     

     This visitor's visit methods completely traverse all elements of a type signature.

174. sealed abstract class Type extends UID with Ordered[Type]

     

     Represents a JVM type.

     Represents a JVM type.

     Programmatically, we distinguish three major kinds of types:

     • base types/primitive types
     • reference types
     • the type void.

     General Information

     From the JVM specification

     There are three kinds of reference types: class types, array types, and interface types. Their values are references to dynamically created class instances, arrays, or class instances or arrays that implement interfaces, respectively.

     A reference value may also be the special null reference, a reference to no object, which will be denoted here by null. The null reference initially has no runtime type, but may be cast to any type. The default value of a reference type is null. The Java virtual machine specification does not mandate a concrete value encoding null.

     Comparing Types/Performance

     Given that the comparison of types is a standard operation in static analysis that is usually done over and over again great care was taken to enable an efficient comparison of types. It is - without exception - always possible to compare types using reference equality (i.e., the eq/ne operators). For each type there will always be at most one object that represents that specific type.

     Additionally, a stable order is defined between types that is based on a type's kind and the unique id of the types in case of reference types. The order is: void type < primitive types < array types < class/interface types

175. case class TypeAnnotation(target: TypeAnnotationTarget, path: TypeAnnotationPath, annotationType: FieldType, elementValuePairs: ElementValuePairs) extends Product with Serializable

     

     A type annotation (*TA*).

     A type annotation (*TA*).

     TypeAnnotations were introduced with Java 8 and are associated with a ClassFile, Field, Method or Code using a org.opalj.br.RuntimeInvisibleTypeAnnotationTable or a org.opalj.br.RuntimeVisibleTypeAnnotationTable attribute.

176. sealed trait TypeAnnotationPath extends AnyRef

     

     The path that describes which type is actually annotated using a TypeAnnotation.

177. sealed trait TypeAnnotationPathElement extends AnyRef

     

     An element of the path that describes which type is actually annotated using a TypeAnnotation.

178. trait TypeAnnotationTable extends Attribute

     

     The runtime (in)visible type annotations of a class, method, field or code block.

     The runtime (in)visible type annotations of a class, method, field or code block.

     Note

     For further information about type-level annotations go to: http://cr.openjdk.java.net/~abuckley/8misc.pdf.

179. sealed trait TypeAnnotationTarget extends AnyRef

     

     Describes the kind of the target of a TypeAnnotation.

180. type TypeAnnotations = IndexedSeq[TypeAnnotation]

     

181. sealed trait TypeArgument extends SignatureElement

     
     See also

     For matching signatures see Signature.

182. trait TypeConversionFactory[T] extends AnyRef

     

     A factory to create instruction sequences to convert one primitive type into another one.

183. case class TypeDeclaration(objectType: ObjectType, isInterfaceType: Boolean, theSuperclassType: Option[ObjectType], theSuperinterfaceTypes: Set[ObjectType]) extends Product with Serializable

     

     Stores information about a type's supertypes.

184. case class TypeIdentifier(t: Type) extends StructureIdentifier with Product with Serializable

     

185. trait TypeSignature extends ReturnTypeSignature

     

186. case class TypeVariableSignature(identifier: String) extends FieldTypeSignature with ThrowsSignature with Product with Serializable

     
     See also

     For matching signatures see Signature.

187. class TypesVisitor extends TraversingVisitor

     

     Traverses a signature and calls for each Type the given method.

     Traverses a signature and calls for each Type the given method.

     Thread Safety

     This class is thread-safe and reusable. I.e., you can use one instance of this visitor to simultaneously process multiple signatures. In this case, however, the given function f also has to be thread safe or you have to use different functions.

188. case class UninitializedVariableInfo(offset: Int) extends VerificationTypeInfo with Product with Serializable

     

189. case class UnknownAttribute(attributeName: String, info: Array[Byte]) extends Attribute with Product with Serializable

     

     Represents (as a byte array) attributes that are not directly supported by OPAL.

190. case class UnpackedLineNumberTable(lineNumbers: LineNumbers) extends LineNumberTable with Product with Serializable

     

     A method's line number table.

191. type UpperTypeBound = UIDSet[ReferenceType]

     

     An upper type bound represents the available type information about a reference value.

     An upper type bound represents the available type information about a reference value. It is always "just" an upper bound for a concrete type; i.e., we know that the runtime type has to be a subtype (reflexive) of the type identified by the upper bound. Furthermore, an upper bound can identify multiple independent types. E.g., a type bound for array objects could be: java.io.Serializable and java.lang.Cloneable. Here, independent means that no two types of the bound are in a subtype relationship. Hence, an upper bound is always a special set where the values are not equal and are not in an inheritance relation. However, identifying independent types is a class hierarchy's responsibility.

     In general, an upper bound identifies a single class type and a set of independent interface types that are known to be implemented by the current object. Even if the type contains a class type it may just be a super class of the concrete type and, hence, just represent an abstraction.

192. sealed trait VarianceIndicator extends SignatureElement

     

     Indicates a TypeArgument's variance.

193. sealed trait VerificationTypeInfo extends AnyRef

     

     Part of the Java 6 stack map table attribute.

194. type VerificationTypeInfoLocals = IndexedSeq[VerificationTypeInfo]

     

195. type VerificationTypeInfoStack = IndexedSeq[VerificationTypeInfo]

     

196. final case class VirtualClass(thisType: ObjectType) extends VirtualSourceElement with Product with Serializable

     

     Represents a class for which we have found some references but have not analyzed any class file or do not want to keep the reference to the underlying class file.

197. sealed trait VirtualClassMember extends VirtualSourceElement

     

198. final case class VirtualField(declaringClassType: ObjectType, name: String, fieldType: FieldType) extends VirtualClassMember with Product with Serializable

     

     Represents a field of a virtual class.

199. final class VirtualForwardingMethod extends VirtualMethod

     

200. sealed class VirtualMethod extends VirtualClassMember

     

     Represents a method of a virtual class.

201. sealed trait VirtualSourceElement extends SourceElement with Ordered[VirtualSourceElement]

     

     A VirtualSourceElement is the representation of some source element that is always detached from the concrete source element that represents the implementation.

202. sealed abstract class VoidType extends Type with ReturnTypeSignature

     

     Represents the Java type/keyword void.

203. sealed trait Wildcard extends TypeArgument

     

     If a type argument is not further specified (e.g.

     If a type argument is not further specified (e.g. List<?> l = …) then the type argument "?" is represented by this object.

     See also

     For matching signatures see Signature.