Package gnu.bytecode

Class ObjectType

    • Field Detail

      • flags

        public int flags
    • Constructor Detail

      • ObjectType

        protected ObjectType()
      • ObjectType

        public ObjectType​(String name)
    • Method Detail

      • isExisting

        public final boolean isExisting()
        Overrides:
        isExisting in class Type
      • setExisting

        public final void setExisting​(boolean existing)
      • getInternalName

        public String getInternalName()
        Returns class name if a class type, signature if an array type. In both cases, uses '/' rather than '.' after packages prefixes. Seems rather arbitrary - but that is how classes are represented in the constant pool (CONSTANT_Class constants). Also, Class.forName is the same, except using '.'.
      • getContextClassLoader

        public static ClassLoader getContextClassLoader()
      • getReflectClass

        public Class getReflectClass()
        Get the java.lang.Class object for the representation type.
        Overrides:
        getReflectClass in class Type
      • getSuperclass

        public ClassType getSuperclass()
      • getInterfaces

        public ClassType[] getInterfaces()
      • getField

        public Field getField​(String name,
                              int mask)
      • getMethods

        public int getMethods​(Filter filter,
                              int searchSupers,
                              List<Method> result)
      • compare

        public int compare​(Type other)
        Description copied from class: Type
        Return a numeric code showing "subtype" relationship: 1: if other is a pure subtype of this; 0: if has the same values; -1: if this is a pure subtype of other; -2: if they have values in common but neither is a subtype of the other; -3: if the types have no values in common. "Same values" is rather loose; by "A is a subtype of B" we mean that all instance of A can be "widened" to B. More formally, A.compare(B) returns: 1: all B values can be converted to A without a coercion failure (i.e. a ClassCastException or overflow or major loss of information), but not vice versa. 0: all A values can be converted to B without a coercion failure and vice versa; -1: all A values can be converted to B without a coercion failure but not vice versa; -2: there are (potentially) some A values that can be converted to B, and some B values can be converted to A; -3: there are no A values that can be converted to B, and neither are there any B values that can be converted to A.
        Specified by:
        compare in class Type
      • coerceFromObject

        public Object coerceFromObject​(Object obj)
        Description copied from class: Type
        Convert an object to a value of this Type. The result is actually of the implementation type, boxed as appropriate, so it is suitable for standard reflective operations, like the arguments to Field#set or Method#invoke. Throw a ClassCastException when this is not possible.
        Specified by:
        coerceFromObject in class Type
      • emitCoerceFromObject

        public void emitCoerceFromObject​(CodeAttr code)
        Compile (in given method) cast from Object to this Type.
        Overrides:
        emitCoerceFromObject in class Type