Back to index...

	/*
	* Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package com.sun.tools.jdi;

	import com.sun.jdi.*;
	import com.sun.jdi.request.*;
	import com.sun.tools.jdi.JDWP;

	import java.util.*;

	/**
	* This interface is used to create and remove Breakpoints, Watchpoints,
	* etc.
	* It include implementations of all the request interfaces..
	*/
	// Warnings from List filters and List[] requestLists is hard to fix.
	// Remove SuppressWarning when we fix the warnings from List filters
	// and List[] requestLists. The generic array is not supported.
	@SuppressWarnings("unchecked")
	class EventRequestManagerImpl extends MirrorImpl
	implements EventRequestManager
	{
	List<? extends EventRequest>[] requestLists;
	private static int methodExitEventCmd = 0;

	static int JDWPtoJDISuspendPolicy(byte jdwpPolicy) {
	switch(jdwpPolicy) {
	case JDWP.SuspendPolicy.ALL:
	return EventRequest.SUSPEND_ALL;
	case JDWP.SuspendPolicy.EVENT_THREAD:
	return EventRequest.SUSPEND_EVENT_THREAD;
	case JDWP.SuspendPolicy.NONE:
	return EventRequest.SUSPEND_NONE;
	default:
	throw new IllegalArgumentException("Illegal policy constant: " + jdwpPolicy);
	}
	}

	static byte JDItoJDWPSuspendPolicy(int jdiPolicy) {
	switch(jdiPolicy) {
	case EventRequest.SUSPEND_ALL:
	return JDWP.SuspendPolicy.ALL;
	case EventRequest.SUSPEND_EVENT_THREAD:
	return JDWP.SuspendPolicy.EVENT_THREAD;
	case EventRequest.SUSPEND_NONE:
	return JDWP.SuspendPolicy.NONE;
	default:
	throw new IllegalArgumentException("Illegal policy constant: " + jdiPolicy);
	}
	}

	/*
	* Override superclass back to default equality
	*/
	public boolean equals(Object obj) {
	return this == obj;
	}

	public int hashCode() {
	return System.identityHashCode(this);
	}

	abstract class EventRequestImpl extends MirrorImpl implements EventRequest {
	int id;

	/*
	* This list is not protected by a synchronized wrapper. All
	* access/modification should be protected by synchronizing on
	* the enclosing instance of EventRequestImpl.
	*/
	List<Object> filters = new ArrayList<>();

	boolean isEnabled = false;
	boolean deleted = false;
	byte suspendPolicy = JDWP.SuspendPolicy.ALL;
	private Map<Object, Object> clientProperties = null;

	EventRequestImpl() {
	super(EventRequestManagerImpl.this.vm);
	}


	/*
	* Override superclass back to default equality
	*/
	public boolean equals(Object obj) {
	return this == obj;
	}

	public int hashCode() {
	return System.identityHashCode(this);
	}

	abstract int eventCmd();

	InvalidRequestStateException invalidState() {
	return new InvalidRequestStateException(toString());
	}

	String state() {
	return deleted? " (deleted)" :
	(isEnabled()? " (enabled)" : " (disabled)");
	}

	/**
	* @return all the event request of this kind
	*/
	List requestList() {
	return EventRequestManagerImpl.this.requestList(eventCmd());
	}

	/**
	* delete the event request
	*/
	void delete() {
	if (!deleted) {
	requestList().remove(this);
	disable(); /* must do BEFORE delete */
	deleted = true;
	}
	}

	public boolean isEnabled() {
	return isEnabled;
	}

	public void enable() {
	setEnabled(true);
	}

	public void disable() {
	setEnabled(false);
	}

	public synchronized void setEnabled(boolean val) {
	if (deleted) {
	throw invalidState();
	} else {
	if (val != isEnabled) {
	if (isEnabled) {
	clear();
	} else {
	set();
	}
	}
	}
	}

	public synchronized void addCountFilter(int count) {
	if (isEnabled() \|\| deleted) {
	throw invalidState();
	}
	if (count < 1) {
	throw new IllegalArgumentException("count is less than one");
	}
	filters.add(JDWP.EventRequest.Set.Modifier.Count.create(count));
	}

	public void setSuspendPolicy(int policy) {
	if (isEnabled() \|\| deleted) {
	throw invalidState();
	}
	suspendPolicy = JDItoJDWPSuspendPolicy(policy);
	}

	public int suspendPolicy() {
	return JDWPtoJDISuspendPolicy(suspendPolicy);
	}

	/**
	* set (enable) the event request
	*/
	synchronized void set() {
	JDWP.EventRequest.Set.Modifier[] mods =
	filters.toArray(
	new JDWP.EventRequest.Set.Modifier[filters.size()]);
	try {
	id = JDWP.EventRequest.Set.process(vm, (byte)eventCmd(),
	suspendPolicy, mods).requestID;
	} catch (JDWPException exc) {
	throw exc.toJDIException();
	}
	isEnabled = true;
	}

	synchronized void clear() {
	try {
	JDWP.EventRequest.Clear.process(vm, (byte)eventCmd(), id);
	} catch (JDWPException exc) {
	throw exc.toJDIException();
	}
	isEnabled = false;
	}

	/**
	* @return a small Map
	* @see #putProperty
	* @see #getProperty
	*/
	private Map<Object, Object> getProperties() {
	if (clientProperties == null) {
	clientProperties = new HashMap<Object, Object>(2);
	}
	return clientProperties;
	}

	/**
	* Returns the value of the property with the specified key. Only
	* properties added with <code>putProperty</code> will return
	* a non-null value.
	*
	* @return the value of this property or null
	* @see #putProperty
	*/
	public final Object getProperty(Object key) {
	if (clientProperties == null) {
	return null;
	} else {
	return getProperties().get(key);
	}
	}

	/**
	* Add an arbitrary key/value "property" to this component.
	*
	* @see #getProperty
	*/
	public final void putProperty(Object key, Object value) {
	if (value != null) {
	getProperties().put(key, value);
	} else {
	getProperties().remove(key);
	}
	}
	}

	abstract class ThreadVisibleEventRequestImpl extends EventRequestImpl {
	public synchronized void addThreadFilter(ThreadReference thread) {
	validateMirror(thread);
	if (isEnabled() \|\| deleted) {
	throw invalidState();
	}
	filters.add(JDWP.EventRequest.Set.Modifier.ThreadOnly
	.create((ThreadReferenceImpl)thread));
	}
	}

	abstract class ClassVisibleEventRequestImpl
	extends ThreadVisibleEventRequestImpl {
	public synchronized void addClassFilter(ReferenceType clazz) {
	validateMirror(clazz);
	if (isEnabled() \|\| deleted) {
	throw invalidState();
	}
	filters.add(JDWP.EventRequest.Set.Modifier.ClassOnly
	.create((ReferenceTypeImpl)clazz));
	}

	public synchronized void addClassFilter(String classPattern) {
	if (isEnabled() \|\| deleted) {
	throw invalidState();
	}
	if (classPattern == null) {
	throw new NullPointerException();
	}
	filters.add(JDWP.EventRequest.Set.Modifier.ClassMatch
	.create(classPattern));
	}

	public synchronized void addClassExclusionFilter(String classPattern) {
	if (isEnabled() \|\| deleted) {
	throw invalidState();
	}
	if (classPattern == null) {
	throw new NullPointerException();
	}
	filters.add(JDWP.EventRequest.Set.Modifier.ClassExclude
	.create(classPattern));
	}

	public synchronized void addInstanceFilter(ObjectReference instance) {
	validateMirror(instance);
	if (isEnabled() \|\| deleted) {
	throw invalidState();
	}
	if (!vm.canUseInstanceFilters()) {
	throw new UnsupportedOperationException(
	"target does not support instance filters");
	}
	filters.add(JDWP.EventRequest.Set.Modifier.InstanceOnly
	.create((ObjectReferenceImpl)instance));
	}
	}

	class BreakpointRequestImpl extends ClassVisibleEventRequestImpl
	implements BreakpointRequest {
	private final Location location;

	BreakpointRequestImpl(Location location) {
	this.location = location;
	filters.add(0,JDWP.EventRequest.Set.Modifier.LocationOnly
	.create(location));
	requestList().add(this);
	}

	public Location location() {
	return location;
	}

	int eventCmd() {
	return JDWP.EventKind.BREAKPOINT;
	}

	public String toString() {
	return "breakpoint request " + location() + state();
	}
	}

	class ClassPrepareRequestImpl extends ClassVisibleEventRequestImpl
	implements ClassPrepareRequest {
	ClassPrepareRequestImpl() {
	requestList().add(this);
	}

	int eventCmd() {
	return JDWP.EventKind.CLASS_PREPARE;
	}

	public synchronized void addSourceNameFilter(String sourceNamePattern) {
	if (isEnabled() \|\| deleted) {
	throw invalidState();
	}
	if (!vm.canUseSourceNameFilters()) {
	throw new UnsupportedOperationException(
	"target does not support source name filters");
	}
	if (sourceNamePattern == null) {
	throw new NullPointerException();
	}

	filters.add(JDWP.EventRequest.Set.Modifier.SourceNameMatch
	.create(sourceNamePattern));
	}

	public String toString() {
	return "class prepare request " + state();
	}
	}

	class ClassUnloadRequestImpl extends ClassVisibleEventRequestImpl
	implements ClassUnloadRequest {
	ClassUnloadRequestImpl() {
	requestList().add(this);
	}

	int eventCmd() {
	return JDWP.EventKind.CLASS_UNLOAD;
	}

	public String toString() {
	return "class unload request " + state();
	}
	}

	class ExceptionRequestImpl extends ClassVisibleEventRequestImpl
	implements ExceptionRequest {
	ReferenceType exception = null;
	boolean caught = true;
	boolean uncaught = true;

	ExceptionRequestImpl(ReferenceType refType,
	boolean notifyCaught, boolean notifyUncaught) {
	exception = refType;
	caught = notifyCaught;
	uncaught = notifyUncaught;
	{
	ReferenceTypeImpl exc;
	if (exception == null) {
	exc = new ClassTypeImpl(vm, 0);
	} else {
	exc = (ReferenceTypeImpl)exception;
	}
	filters.add(JDWP.EventRequest.Set.Modifier.ExceptionOnly.
	create(exc, caught, uncaught));
	}
	requestList().add(this);
	}

	public ReferenceType exception() {
	return exception;
	}

	public boolean notifyCaught() {
	return caught;
	}

	public boolean notifyUncaught() {
	return uncaught;
	}

	int eventCmd() {
	return JDWP.EventKind.EXCEPTION;
	}

	public String toString() {
	return "exception request " + exception() + state();
	}
	}

	class MethodEntryRequestImpl extends ClassVisibleEventRequestImpl
	implements MethodEntryRequest {
	MethodEntryRequestImpl() {
	requestList().add(this);
	}

	int eventCmd() {
	return JDWP.EventKind.METHOD_ENTRY;
	}

	public String toString() {
	return "method entry request " + state();
	}
	}

	class MethodExitRequestImpl extends ClassVisibleEventRequestImpl
	implements MethodExitRequest {
	MethodExitRequestImpl() {
	if (methodExitEventCmd == 0) {
	/*
	* If we can get return values, then we always get them.
	* Thus, for JDI MethodExitRequests, we always use the
	* same JDWP EventKind. Here we decide which to use and
	* save it so that it will be used for all future
	* MethodExitRequests.
	*
	* This call to canGetMethodReturnValues can't
	* be done in the EventRequestManager ctor because that is too early.
	*/
	if (vm.canGetMethodReturnValues()) {
	methodExitEventCmd = JDWP.EventKind.METHOD_EXIT_WITH_RETURN_VALUE;
	} else {
	methodExitEventCmd = JDWP.EventKind.METHOD_EXIT;
	}
	}
	requestList().add(this);
	}

	int eventCmd() {
	return EventRequestManagerImpl.methodExitEventCmd;
	}

	public String toString() {
	return "method exit request " + state();
	}
	}

	class MonitorContendedEnterRequestImpl extends ClassVisibleEventRequestImpl
	implements MonitorContendedEnterRequest {
	MonitorContendedEnterRequestImpl() {
	requestList().add(this);
	}

	int eventCmd() {
	return JDWP.EventKind.MONITOR_CONTENDED_ENTER;
	}

	public String toString() {
	return "monitor contended enter request " + state();
	}
	}

	class MonitorContendedEnteredRequestImpl extends ClassVisibleEventRequestImpl
	implements MonitorContendedEnteredRequest {
	MonitorContendedEnteredRequestImpl() {
	requestList().add(this);
	}

	int eventCmd() {
	return JDWP.EventKind.MONITOR_CONTENDED_ENTERED;
	}

	public String toString() {
	return "monitor contended entered request " + state();
	}
	}

	class MonitorWaitRequestImpl extends ClassVisibleEventRequestImpl
	implements MonitorWaitRequest {
	MonitorWaitRequestImpl() {
	requestList().add(this);
	}

	int eventCmd() {
	return JDWP.EventKind.MONITOR_WAIT;
	}

	public String toString() {
	return "monitor wait request " + state();
	}
	}

	class MonitorWaitedRequestImpl extends ClassVisibleEventRequestImpl
	implements MonitorWaitedRequest {
	MonitorWaitedRequestImpl() {
	requestList().add(this);
	}

	int eventCmd() {
	return JDWP.EventKind.MONITOR_WAITED;
	}

	public String toString() {
	return "monitor waited request " + state();
	}
	}

	class StepRequestImpl extends ClassVisibleEventRequestImpl
	implements StepRequest {
	ThreadReferenceImpl thread;
	int size;
	int depth;

	StepRequestImpl(ThreadReference thread, int size, int depth) {
	this.thread = (ThreadReferenceImpl)thread;
	this.size = size;
	this.depth = depth;

	/*
	* Translate size and depth to corresponding JDWP values.
	*/
	int jdwpSize;
	switch (size) {
	case STEP_MIN:
	jdwpSize = JDWP.StepSize.MIN;
	break;
	case STEP_LINE:
	jdwpSize = JDWP.StepSize.LINE;
	break;
	default:
	throw new IllegalArgumentException("Invalid step size");
	}

	int jdwpDepth;
	switch (depth) {
	case STEP_INTO:
	jdwpDepth = JDWP.StepDepth.INTO;
	break;
	case STEP_OVER:
	jdwpDepth = JDWP.StepDepth.OVER;
	break;
	case STEP_OUT:
	jdwpDepth = JDWP.StepDepth.OUT;
	break;
	default:
	throw new IllegalArgumentException("Invalid step depth");
	}

	/*
	* Make sure this isn't a duplicate
	*/
	List<StepRequest> requests = stepRequests();
	Iterator<StepRequest> iter = requests.iterator();
	while (iter.hasNext()) {
	StepRequest request = iter.next();
	if ((request != this) &&
	request.isEnabled() &&
	request.thread().equals(thread)) {
	throw new DuplicateRequestException(
	"Only one step request allowed per thread");
	}
	}

	filters.add(JDWP.EventRequest.Set.Modifier.Step.
	create(this.thread, jdwpSize, jdwpDepth));
	requestList().add(this);

	}
	public int depth() {
	return depth;
	}

	public int size() {
	return size;
	}

	public ThreadReference thread() {
	return thread;
	}

	int eventCmd() {
	return JDWP.EventKind.SINGLE_STEP;
	}

	public String toString() {
	return "step request " + thread() + state();
	}
	}

	class ThreadDeathRequestImpl extends ThreadVisibleEventRequestImpl
	implements ThreadDeathRequest {
	ThreadDeathRequestImpl() {
	requestList().add(this);
	}

	int eventCmd() {
	return JDWP.EventKind.THREAD_DEATH;
	}

	public String toString() {
	return "thread death request " + state();
	}
	}

	class ThreadStartRequestImpl extends ThreadVisibleEventRequestImpl
	implements ThreadStartRequest {
	ThreadStartRequestImpl() {
	requestList().add(this);
	}

	int eventCmd() {
	return JDWP.EventKind.THREAD_START;
	}

	public String toString() {
	return "thread start request " + state();
	}
	}

	abstract class WatchpointRequestImpl extends ClassVisibleEventRequestImpl
	implements WatchpointRequest {
	final Field field;

	WatchpointRequestImpl(Field field) {
	this.field = field;
	filters.add(0,
	JDWP.EventRequest.Set.Modifier.FieldOnly.create(
	(ReferenceTypeImpl)field.declaringType(),
	((FieldImpl)field).ref()));
	}

	public Field field() {
	return field;
	}
	}

	class AccessWatchpointRequestImpl extends WatchpointRequestImpl
	implements AccessWatchpointRequest {
	AccessWatchpointRequestImpl(Field field) {
	super(field);
	requestList().add(this);
	}

	int eventCmd() {
	return JDWP.EventKind.FIELD_ACCESS;
	}

	public String toString() {
	return "access watchpoint request " + field + state();
	}
	}

	class ModificationWatchpointRequestImpl extends WatchpointRequestImpl
	implements ModificationWatchpointRequest {
	ModificationWatchpointRequestImpl(Field field) {
	super(field);
	requestList().add(this);
	}

	int eventCmd() {
	return JDWP.EventKind.FIELD_MODIFICATION;
	}

	public String toString() {
	return "modification watchpoint request " + field + state();
	}
	}

	class VMDeathRequestImpl extends EventRequestImpl
	implements VMDeathRequest {
	VMDeathRequestImpl() {
	requestList().add(this);
	}

	int eventCmd() {
	return JDWP.EventKind.VM_DEATH;
	}

	public String toString() {
	return "VM death request " + state();
	}
	}

	/**
	* Constructor.
	*/
	EventRequestManagerImpl(VirtualMachine vm) {
	super(vm);
	java.lang.reflect.Field[] ekinds =
	JDWP.EventKind.class.getDeclaredFields();
	int highest = 0;
	for (int i = 0; i < ekinds.length; ++i) {
	int val;
	try {
	val = ekinds[i].getInt(null);
	} catch (IllegalAccessException exc) {
	throw new RuntimeException("Got: " + exc);
	}
	if (val > highest) {
	highest = val;
	}
	}
	requestLists = new List[highest+1];
	for (int i=0; i <= highest; i++) {
	requestLists[i] = new ArrayList<>();
	}
	}

	public ClassPrepareRequest createClassPrepareRequest() {
	return new ClassPrepareRequestImpl();
	}

	public ClassUnloadRequest createClassUnloadRequest() {
	return new ClassUnloadRequestImpl();
	}

	public ExceptionRequest createExceptionRequest(ReferenceType refType,
	boolean notifyCaught,
	boolean notifyUncaught) {
	validateMirrorOrNull(refType);
	return new ExceptionRequestImpl(refType, notifyCaught, notifyUncaught);
	}

	public StepRequest createStepRequest(ThreadReference thread,
	int size, int depth) {
	validateMirror(thread);
	return new StepRequestImpl(thread, size, depth);
	}

	public ThreadDeathRequest createThreadDeathRequest() {
	return new ThreadDeathRequestImpl();
	}

	public ThreadStartRequest createThreadStartRequest() {
	return new ThreadStartRequestImpl();
	}

	public MethodEntryRequest createMethodEntryRequest() {
	return new MethodEntryRequestImpl();
	}

	public MethodExitRequest createMethodExitRequest() {
	return new MethodExitRequestImpl();
	}

	public MonitorContendedEnterRequest createMonitorContendedEnterRequest() {
	if (!vm.canRequestMonitorEvents()) {
	throw new UnsupportedOperationException(
	"target VM does not support requesting Monitor events");
	}
	return new MonitorContendedEnterRequestImpl();
	}

	public MonitorContendedEnteredRequest createMonitorContendedEnteredRequest() {
	if (!vm.canRequestMonitorEvents()) {
	throw new UnsupportedOperationException(
	"target VM does not support requesting Monitor events");
	}
	return new MonitorContendedEnteredRequestImpl();
	}

	public MonitorWaitRequest createMonitorWaitRequest() {
	if (!vm.canRequestMonitorEvents()) {
	throw new UnsupportedOperationException(
	"target VM does not support requesting Monitor events");
	}
	return new MonitorWaitRequestImpl();
	}

	public MonitorWaitedRequest createMonitorWaitedRequest() {
	if (!vm.canRequestMonitorEvents()) {
	throw new UnsupportedOperationException(
	"target VM does not support requesting Monitor events");
	}
	return new MonitorWaitedRequestImpl();
	}

	public BreakpointRequest createBreakpointRequest(Location location) {
	validateMirror(location);
	if (location.codeIndex() == -1) {
	throw new NativeMethodException("Cannot set breakpoints on native methods");
	}
	return new BreakpointRequestImpl(location);
	}

	public AccessWatchpointRequest
	createAccessWatchpointRequest(Field field) {
	validateMirror(field);
	if (!vm.canWatchFieldAccess()) {
	throw new UnsupportedOperationException(
	"target VM does not support access watchpoints");
	}
	return new AccessWatchpointRequestImpl(field);
	}

	public ModificationWatchpointRequest
	createModificationWatchpointRequest(Field field) {
	validateMirror(field);
	if (!vm.canWatchFieldModification()) {
	throw new UnsupportedOperationException(
	"target VM does not support modification watchpoints");
	}
	return new ModificationWatchpointRequestImpl(field);
	}

	public VMDeathRequest createVMDeathRequest() {
	if (!vm.canRequestVMDeathEvent()) {
	throw new UnsupportedOperationException(
	"target VM does not support requesting VM death events");
	}
	return new VMDeathRequestImpl();
	}

	public void deleteEventRequest(EventRequest eventRequest) {
	validateMirror(eventRequest);
	((EventRequestImpl)eventRequest).delete();
	}

	public void deleteEventRequests(List<? extends EventRequest> eventRequests) {
	validateMirrors(eventRequests);
	// copy the eventRequests to avoid ConcurrentModificationException
	Iterator<? extends EventRequest> iter = (new ArrayList<>(eventRequests)).iterator();
	while (iter.hasNext()) {
	((EventRequestImpl)iter.next()).delete();
	}
	}

	public void deleteAllBreakpoints() {
	requestList(JDWP.EventKind.BREAKPOINT).clear();

	try {
	JDWP.EventRequest.ClearAllBreakpoints.process(vm);
	} catch (JDWPException exc) {
	throw exc.toJDIException();
	}
	}

	public List<StepRequest> stepRequests() {
	return (List<StepRequest>)unmodifiableRequestList(JDWP.EventKind.SINGLE_STEP);
	}

	public List<ClassPrepareRequest> classPrepareRequests() {
	return (List<ClassPrepareRequest>)unmodifiableRequestList(JDWP.EventKind.CLASS_PREPARE);
	}

	public List<ClassUnloadRequest> classUnloadRequests() {
	return (List<ClassUnloadRequest>)unmodifiableRequestList(JDWP.EventKind.CLASS_UNLOAD);
	}

	public List<ThreadStartRequest> threadStartRequests() {
	return (List<ThreadStartRequest>)unmodifiableRequestList(JDWP.EventKind.THREAD_START);
	}

	public List<ThreadDeathRequest> threadDeathRequests() {
	return (List<ThreadDeathRequest>)unmodifiableRequestList(JDWP.EventKind.THREAD_DEATH);
	}

	public List<ExceptionRequest> exceptionRequests() {
	return (List<ExceptionRequest>)unmodifiableRequestList(JDWP.EventKind.EXCEPTION);
	}

	public List<BreakpointRequest> breakpointRequests() {
	return (List<BreakpointRequest>)unmodifiableRequestList(JDWP.EventKind.BREAKPOINT);
	}

	public List<AccessWatchpointRequest> accessWatchpointRequests() {
	return (List<AccessWatchpointRequest>)unmodifiableRequestList(JDWP.EventKind.FIELD_ACCESS);
	}

	public List<ModificationWatchpointRequest> modificationWatchpointRequests() {
	return (List<ModificationWatchpointRequest>)unmodifiableRequestList(JDWP.EventKind.FIELD_MODIFICATION);
	}

	public List<MethodEntryRequest> methodEntryRequests() {
	return (List<MethodEntryRequest>)unmodifiableRequestList(JDWP.EventKind.METHOD_ENTRY);
	}

	public List<MethodExitRequest> methodExitRequests() {
	return (List<MethodExitRequest>)unmodifiableRequestList(
	EventRequestManagerImpl.methodExitEventCmd);
	}

	public List<MonitorContendedEnterRequest> monitorContendedEnterRequests() {
	return (List<MonitorContendedEnterRequest>)unmodifiableRequestList(JDWP.EventKind.MONITOR_CONTENDED_ENTER);
	}

	public List<MonitorContendedEnteredRequest> monitorContendedEnteredRequests() {
	return (List<MonitorContendedEnteredRequest>)unmodifiableRequestList(JDWP.EventKind.MONITOR_CONTENDED_ENTERED);
	}

	public List<MonitorWaitRequest> monitorWaitRequests() {
	return (List<MonitorWaitRequest>)unmodifiableRequestList(JDWP.EventKind.MONITOR_WAIT);
	}

	public List<MonitorWaitedRequest> monitorWaitedRequests() {
	return (List<MonitorWaitedRequest>)unmodifiableRequestList(JDWP.EventKind.MONITOR_WAITED);
	}

	public List<VMDeathRequest> vmDeathRequests() {
	return (List<VMDeathRequest>)unmodifiableRequestList(JDWP.EventKind.VM_DEATH);
	}

	List<? extends EventRequest> unmodifiableRequestList(int eventCmd) {
	return Collections.unmodifiableList(requestList(eventCmd));
	}

	EventRequest request(int eventCmd, int requestId) {
	List<? extends EventRequest> rl = requestList(eventCmd);
	for (int i = rl.size() - 1; i >= 0; i--) {
	EventRequestImpl er = (EventRequestImpl)rl.get(i);
	if (er.id == requestId) {
	return er;
	}
	}
	return null;
	}

	List<? extends EventRequest> requestList(int eventCmd) {
	return requestLists[eventCmd];
	}

	}

Back to index...