Interface InterfaceType

All Superinterfaces:

Accessible, Comparable<ReferenceType>, Mirror, ReferenceType, Type

public interface InterfaceType
extends ReferenceType

A mirror of an interface in the target VM. An InterfaceType is a refinement of ReferenceType that applies to true interfaces in the JLS sense of the definition (not a class, not an array type). An interface type will never be returned by ObjectReference.referenceType(), but it may be in the list of implemented interfaces for a ClassType that is returned by that method.

Since:

1.3

See Also:

• ObjectReference

Method Summary

Modifier and Type	Method	Description
List<ClassType>	implementors()	Gets the currently prepared classes which directly implement this interface.
default Value	invokeMethod(ThreadReference thread, Method method, List<? extends Value> arguments, int options)	Invokes the specified static Method in the target VM.
List<InterfaceType>	subinterfaces()	Gets the currently prepared interfaces which directly extend this interface.
List<InterfaceType>	superinterfaces()	Gets the interfaces directly extended by this interface.

Methods declared in interface com.sun.jdi.Accessible

isPackagePrivate, isPrivate, isProtected, isPublic, modifiers

Methods declared in interface java.lang.Comparable

compareTo

Methods declared in interface com.sun.jdi.Mirror

toString, virtualMachine

Methods declared in interface com.sun.jdi.ReferenceType

allFields, allLineLocations, allLineLocations, allMethods, availableStrata, classLoader, classObject, constantPool, constantPoolCount, defaultStratum, equals, failedToInitialize, fieldByName, fields, genericSignature, getValue, getValues, hashCode, instances, isAbstract, isFinal, isInitialized, isPrepared, isStatic, isVerified, locationsOfLine, locationsOfLine, majorVersion, methods, methodsByName, methodsByName, minorVersion, module, name, nestedTypes, sourceDebugExtension, sourceName, sourceNames, sourcePaths, visibleFields, visibleMethods

Methods declared in interface com.sun.jdi.Type

signature

Method Details

superinterfaces

List<InterfaceType> superinterfaces()

Gets the interfaces directly extended by this interface. The returned list contains only those interfaces this interface has declared to be extended.

Returns:

a List of InterfaceType objects each mirroring an interface extended by this interface. If none exist, returns a zero length List.

Throws:

ClassNotPreparedException - if this class not yet been prepared.

subinterfaces

List<InterfaceType> subinterfaces()

Gets the currently prepared interfaces which directly extend this interface. The returned list contains only those interfaces that declared this interface in their "extends" clause.

Returns:

a List of InterfaceType objects each mirroring an interface extending this interface. If none exist, returns a zero length List.

implementors

List<ClassType> implementors()

Gets the currently prepared classes which directly implement this interface. The returned list contains only those classes that declared this interface in their "implements" clause.

Returns:

a List of ClassType objects each mirroring a class implementing this interface. If none exist, returns a zero length List.

invokeMethod

default Value invokeMethod(ThreadReference thread,
 Method method,
 List<? extends Value> arguments,
 int options)
                    throws InvalidTypeException,
ClassNotLoadedException,
IncompatibleThreadStateException,
InvocationException

Invokes the specified static Method in the target VM. The specified method must be defined in this interface. The method must be a static method but not a static initializer.

The method invocation will occur in the specified thread. Method invocation can occur only if the specified thread has been suspended by an event which occurred in that thread. Method invocation is not supported when the target VM has been suspended through VirtualMachine.suspend() or when the specified thread is suspended through ThreadReference.suspend().

The specified method is invoked with the arguments in the specified argument list. The method invocation is synchronous; this method does not return until the invoked method returns in the target VM. If the invoked method throws an exception, this method will throw an InvocationException which contains a mirror to the exception object thrown.

Object arguments must be assignment compatible with the argument type (This implies that the argument type must be loaded through the enclosing class's class loader). Primitive arguments must be either assignment compatible with the argument type or must be convertible to the argument type without loss of information. If the method being called accepts a variable number of arguments, then the last argument type is an array of some component type. The argument in the matching position can be omitted, or can be null, an array of the same component type, or an argument of the component type followed by any number of other arguments of the same type. If the argument is omitted, then a 0 length array of the component type is passed. The component type can be a primitive type. Autoboxing is not supported. See Section 5.2 of The Java Language Specification for more information on assignment compatibility.

By default, all threads in the target VM are resumed while the method is being invoked if they were previously suspended by an event or by VirtualMachine.suspend() or ThreadReference.suspend(). This is done to prevent the deadlocks that will occur if any of the threads own resources, such as monitors, that will be needed by the invoked method. Note, however, that this implicit resume acts exactly like ThreadReference.resume(), so if the thread's suspend count is greater than 1, it will remain in a suspended state during the invocation and thus a deadlock could still occur. By default, when the invocation completes, all threads in the target VM are suspended, regardless their state before the invocation. It is possible that breakpoints or other events might occur during the invocation. This can cause deadlocks as described above. It can also cause a deadlock if invokeMethod is called from the client's event handler thread. In this case, this thread will be waiting for the invokeMethod to complete and won't read the EventSet that comes in for the new event. If this new EventSet is SUSPEND_ALL, then a deadlock will occur because no one will resume the EventSet. To avoid this, all EventRequests should be disabled before doing the invokeMethod, or the invokeMethod should not be done from the client's event handler thread.

The resumption of other threads during the invocation can be prevented by specifying the ClassType.INVOKE_SINGLE_THREADED bit flag in the options argument; however, there is no protection against or recovery from the deadlocks described above, so this option should be used with great caution. Only the specified thread will be resumed (as described for all threads above). Upon completion of a single threaded invoke, the invoking thread will be suspended once again. Note that any threads started during the single threaded invocation will not be suspended when the invocation completes.

If the target VM is disconnected during the invoke (for example, through VirtualMachine.dispose()) the method invocation continues.

API Note:

Virtual threads are typically user-mode threads scheduled by the Java runtime rather than the operating system. As such, there may be more cases with virtual threads where the ClassType.INVOKE_SINGLE_THREADED option may cause a deadlock. For example, suspending all threads in the target VM may suspend threads that support the timer mechanism for virtual threads, and thus methods such as Thread.sleep(long) may deadlock.

Parameters:

thread - the thread in which to invoke.

method - the Method to invoke.

arguments - the list of Value arguments bound to the invoked method. Values from the list are assigned to arguments in the order they appear in the method signature.

options - the integer bit flag options.

Returns:

a Value mirror of the invoked method's return value.

Throws:

IllegalArgumentException - if the method is not a member of this interface, if the size of the argument list does not match the number of declared arguments for the method, or if the method is not static or is a static initializer.

ClassNotLoadedException - if any argument type has not yet been loaded through the appropriate class loader.

IncompatibleThreadStateException - if the specified thread has not been suspended by an event.

InvocationException - if the method invocation resulted in an exception in the target VM.

InvalidTypeException - If the arguments do not meet this requirement -- Object arguments must be assignment compatible with the argument type. This implies that the argument type must be loaded through the enclosing class' class loader. Primitive arguments must be either assignment compatible with the argument type or must be convertible to the argument type without loss of information. See JLS section 5.2 for more information on assignment compatibility.

VMCannotBeModifiedException - if the VirtualMachine is read-only - see VirtualMachine.canBeModified().

Since:

1.8