/*******************************************************************************
 * Copyright (c) 2000, 2015 IBM Corporation and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdi.hcr;

import com.sun.jdi.ReferenceType;
import com.sun.jdi.ThreadReference;
import com.sun.jdi.request.StepRequest;

/**
 * A reenter step request is a step event request that will be activated when
 * the given thread is about to pop the top stack frame. At this point, the VM
 * is expected to do the following:
 * <ol>
 * <li>The arguments to the method are carefully set aside, along with the
 * identity of the actual method.
 * <li>The stack frame is popped. Any value being returned is discarded. Any
 * exception being thrown is ignored. Instruction counter in caller is set
 * <i>at</i> (rather than after) the send bytecode.
 * <li>Suspend the thread depending on the suspend policy and report a
 * <code>StepEvent</code> for this request.
 * <li>When the thread is resumed, the method is re-retrieved; if the class had
 * recently been reloaded, this must find the new bytecodes. If the method is no
 * longer present, throw a <code>java.lang.NoSuchMethodError</code> as specified
 * in the Java VM Specification.
 * <li>The method is entered as per normal, using the saved arguments.
 * </ol>
 * <p>
 * Note that other events may need to be reported as well (e.g., hit breakpoint
 * on first instruction). Execution does not reenter the caller at any point; so
 * no step out or step into events are reported.
 *
 */
public interface ReenterStepRequest extends StepRequest {
	/**
	 * Restricts the events generated by this request to those whose location is
	 * in a class whose name does NOT match this restricted regular expression.
	 * e.g. "java.*" or "*.Foo".
	 *
	 * @param classPattern
	 *            the pattern String to filter against.
	 */
	@Override
	public void addClassExclusionFilter(String classPattern);

	/**
	 * Restricts the events generated by this request to those whose location is
	 * in this class..
	 *
	 * @param clazz
	 *            the class to filter on.
	 */
	@Override
	public void addClassFilter(ReferenceType clazz);

	/**
	 * Restricts the events generated by this request to those whose location is
	 * in a class whose name matches this restricted regular expression. e.g.
	 * "java.*" or "*.Foo".
	 *
	 * @param classPattern
	 *            the pattern String to filter for.
	 */
	@Override
	public void addClassFilter(String classPattern);

	/**
	 * @return the thread on which the step event is being requested.
	 */
	@Override
	public ThreadReference thread();
}
