com.sun.jdi.event.EventSet Java Examples

EventSet removeInternal() throws InterruptedException {
    EventSet eventSet;
    do {
        // Waiting forever, so removeUnfiltered() is never null
        eventSet = removeUnfiltered(0).internalFilter();
    } while (eventSet == null || eventSet.isEmpty());

    /*
     * Currently, no internal events are requested with a suspend
     * policy other than none, so we don't check for notifySuspend()
     * here. If this changes in the future, there is much
     * infrastructure that needs to be updated.
     */

    return eventSet;
}
 

EventSet removeInternal() throws InterruptedException {
    EventSet eventSet;
    do {
        // Waiting forever, so removeUnfiltered() is never null
        eventSet = removeUnfiltered(0).internalFilter();
    } while (eventSet == null || eventSet.isEmpty());

    /*
     * Currently, no internal events are requested with a suspend
     * policy other than none, so we don't check for notifySuspend()
     * here. If this changes in the future, there is much
     * infrastructure that needs to be updated.
     */

    return eventSet;
}
 

EventSet removeInternal() throws InterruptedException {
    EventSet eventSet;
    do {
        // Waiting forever, so removeUnfiltered() is never null
        eventSet = removeUnfiltered(0).internalFilter();
    } while (eventSet == null || eventSet.isEmpty());

    /*
     * Currently, no internal events are requested with a suspend
     * policy other than none, so we don't check for notifySuspend()
     * here. If this changes in the future, there is much
     * infrastructure that needs to be updated.
     */

    return eventSet;
}
 

EventSet removeInternal() throws InterruptedException {
    EventSet eventSet;
    do {
        // Waiting forever, so removeUnfiltered() is never null
        eventSet = removeUnfiltered(0).internalFilter();
    } while (eventSet == null || eventSet.isEmpty());

    /*
     * Currently, no internal events are requested with a suspend
     * policy other than none, so we don't check for notifySuspend()
     * here. If this changes in the future, there is much
     * infrastructure that needs to be updated.
     */

    return eventSet;
}
 

private void eventLoop() throws InterruptedException {
	System.out.println("eventLoop started");
	EventQueue eventQueue = vm.eventQueue();
	boolean isRunning = true;
	while (isRunning) {
		EventSet eventSet = eventQueue.remove();
		boolean mayResume = true;
		for (Event event : eventSet) {
			System.out.println(event);
			if (event instanceof VMDeathEvent
					|| event instanceof VMDisconnectEvent) {
				isRunning = false;
			} else if (event instanceof ExceptionEvent) {
				mayResume = false;
			}
		}
		if (mayResume) eventSet.resume();
	}
}
 

EventSet removeInternal() throws InterruptedException {
    EventSet eventSet;
    do {
        // Waiting forever, so removeUnfiltered() is never null
        eventSet = removeUnfiltered(0).internalFilter();
    } while (eventSet == null || eventSet.isEmpty());

    /*
     * Currently, no internal events are requested with a suspend
     * policy other than none, so we don't check for notifySuspend()
     * here. If this changes in the future, there is much
     * infrastructure that needs to be updated.
     */

    return eventSet;
}
 

EventSet removeInternal() throws InterruptedException {
    EventSet eventSet;
    do {
        // Waiting forever, so removeUnfiltered() is never null
        eventSet = removeUnfiltered(0).internalFilter();
    } while (eventSet == null || eventSet.isEmpty());

    /*
     * Currently, no internal events are requested with a suspend
     * policy other than none, so we don't check for notifySuspend()
     * here. If this changes in the future, there is much
     * infrastructure that needs to be updated.
     */

    return eventSet;
}
 

EventSet removeInternal() throws InterruptedException {
    EventSet eventSet;
    do {
        // Waiting forever, so removeUnfiltered() is never null
        eventSet = removeUnfiltered(0).internalFilter();
    } while (eventSet == null || eventSet.isEmpty());

    /*
     * Currently, no internal events are requested with a suspend
     * policy other than none, so we don't check for notifySuspend()
     * here. If this changes in the future, there is much
     * infrastructure that needs to be updated.
     */

    return eventSet;
}
 

EventSet removeInternal() throws InterruptedException {
    EventSet eventSet;
    do {
        // Waiting forever, so removeUnfiltered() is never null
        eventSet = removeUnfiltered(0).internalFilter();
    } while (eventSet == null || eventSet.isEmpty());

    /*
     * Currently, no internal events are requested with a suspend
     * policy other than none, so we don't check for notifySuspend()
     * here. If this changes in the future, there is much
     * infrastructure that needs to be updated.
     */

    return eventSet;
}
 

EventSet removeInternal() throws InterruptedException {
    EventSet eventSet;
    do {
        // Waiting forever, so removeUnfiltered() is never null
        eventSet = removeUnfiltered(0).internalFilter();
    } while (eventSet == null || eventSet.isEmpty());

    /*
     * Currently, no internal events are requested with a suspend
     * policy other than none, so we don't check for notifySuspend()
     * here. If this changes in the future, there is much
     * infrastructure that needs to be updated.
     */

    return eventSet;
}
 

EventSet removeInternal() throws InterruptedException {
    EventSet eventSet;
    do {
        // Waiting forever, so removeUnfiltered() is never null
        eventSet = removeUnfiltered(0).internalFilter();
    } while (eventSet == null || eventSet.isEmpty());

    /*
     * Currently, no internal events are requested with a suspend
     * policy other than none, so we don't check for notifySuspend()
     * here. If this changes in the future, there is much
     * infrastructure that needs to be updated.
     */

    return eventSet;
}
 

protected void handleEventCmdSet(Packet p) {
    EventSet eventSet = new EventSetImpl(vm, p);

    if (eventSet != null) {
        queueEventSet(eventSet);
    }
}
 

protected void handleEventCmdSet(Packet p) {
    EventSet eventSet = new EventSetImpl(vm, p);

    if (eventSet != null) {
        queueEventSet(eventSet);
    }
}
 

/**
 * Filter out events not for user's eyes.
 * Then filter out empty sets.
 */
public EventSet remove(long timeout) throws InterruptedException {
    if (timeout < 0) {
        throw new IllegalArgumentException("Timeout cannot be negative");
    }

    EventSet eventSet;
    while (true) {
        EventSetImpl fullEventSet = removeUnfiltered(timeout);
        if (fullEventSet == null) {
            eventSet = null;  // timeout
            break;
        }
        /*
         * Remove events from the event set for which
         * there is no corresponding enabled request (
         * this includes our internally requested events.)
         * This never returns null
         */
        eventSet = fullEventSet.userFilter();
        if (!eventSet.isEmpty()) {
            break;
        }
    }

    if ((eventSet != null) && (eventSet.suspendPolicy() == JDWP.SuspendPolicy.ALL)) {
        vm.notifySuspend();
    }

    return eventSet;
}
 

/**
 * Filter out events not for user's eyes.
 * Then filter out empty sets.
 */
public EventSet remove(long timeout) throws InterruptedException {
    if (timeout < 0) {
        throw new IllegalArgumentException("Timeout cannot be negative");
    }

    EventSet eventSet;
    while (true) {
        EventSetImpl fullEventSet = removeUnfiltered(timeout);
        if (fullEventSet == null) {
            eventSet = null;  // timeout
            break;
        }
        /*
         * Remove events from the event set for which
         * there is no corresponding enabled request (
         * this includes our internally requested events.)
         * This never returns null
         */
        eventSet = fullEventSet.userFilter();
        if (!eventSet.isEmpty()) {
            break;
        }
    }

    if ((eventSet != null) && (eventSet.suspendPolicy() == JDWP.SuspendPolicy.ALL)) {
        vm.notifySuspend();
    }

    return eventSet;
}
 

/**
 * Filter out events not for user's eyes.
 * Then filter out empty sets.
 */
public EventSet remove(long timeout) throws InterruptedException {
    if (timeout < 0) {
        throw new IllegalArgumentException("Timeout cannot be negative");
    }

    EventSet eventSet;
    while (true) {
        EventSetImpl fullEventSet = removeUnfiltered(timeout);
        if (fullEventSet == null) {
            eventSet = null;  // timeout
            break;
        }
        /*
         * Remove events from the event set for which
         * there is no corresponding enabled request (
         * this includes our internally requested events.)
         * This never returns null
         */
        eventSet = fullEventSet.userFilter();
        if (!eventSet.isEmpty()) {
            break;
        }
    }

    if ((eventSet != null) && (eventSet.suspendPolicy() == JDWP.SuspendPolicy.ALL)) {
        vm.notifySuspend();
    }

    return eventSet;
}
 

/**
 * Filter out events not for user's eyes.
 * Then filter out empty sets.
 */
public EventSet remove(long timeout) throws InterruptedException {
    if (timeout < 0) {
        throw new IllegalArgumentException("Timeout cannot be negative");
    }

    EventSet eventSet;
    while (true) {
        EventSetImpl fullEventSet = removeUnfiltered(timeout);
        if (fullEventSet == null) {
            eventSet = null;  // timeout
            break;
        }
        /*
         * Remove events from the event set for which
         * there is no corresponding enabled request (
         * this includes our internally requested events.)
         * This never returns null
         */
        eventSet = fullEventSet.userFilter();
        if (!eventSet.isEmpty()) {
            break;
        }
    }

    if ((eventSet != null) && (eventSet.suspendPolicy() == JDWP.SuspendPolicy.ALL)) {
        vm.notifySuspend();
    }

    return eventSet;
}
 

private void queueEventSet(EventSet eventSet) {
    int maxQueueSize = 0;

    synchronized(eventQueues) {
        Iterator<EventQueue> iter = eventQueues.iterator();
        while (iter.hasNext()) {
            EventQueueImpl queue = (EventQueueImpl)iter.next();
            queue.enqueue(eventSet);
            maxQueueSize = Math.max(maxQueueSize, queue.size());
        }
    }

    controlEventFlow(maxQueueSize);
}
 

protected void handleEventCmdSet(Packet p) {
    EventSet eventSet = new EventSetImpl(vm, p);

    if (eventSet != null) {
        queueEventSet(eventSet);
    }
}
 

private void queueEventSet(EventSet eventSet) {
    int maxQueueSize = 0;

    synchronized(eventQueues) {
        Iterator<EventQueue> iter = eventQueues.iterator();
        while (iter.hasNext()) {
            EventQueueImpl queue = (EventQueueImpl)iter.next();
            queue.enqueue(eventSet);
            maxQueueSize = Math.max(maxQueueSize, queue.size());
        }
    }

    controlEventFlow(maxQueueSize);
}
 

private void queueEventSet(EventSet eventSet) {
    int maxQueueSize = 0;

    synchronized(eventQueues) {
        Iterator<EventQueue> iter = eventQueues.iterator();
        while (iter.hasNext()) {
            EventQueueImpl queue = (EventQueueImpl)iter.next();
            queue.enqueue(eventSet);
            maxQueueSize = Math.max(maxQueueSize, queue.size());
        }
    }

    controlEventFlow(maxQueueSize);
}
 

private void queueEventSet(EventSet eventSet) {
    int maxQueueSize = 0;

    synchronized(eventQueues) {
        Iterator<EventQueue> iter = eventQueues.iterator();
        while (iter.hasNext()) {
            EventQueueImpl queue = (EventQueueImpl)iter.next();
            queue.enqueue(eventSet);
            maxQueueSize = Math.max(maxQueueSize, queue.size());
        }
    }

    controlEventFlow(maxQueueSize);
}
 

/**
 * Filter out events not for user's eyes.
 * Then filter out empty sets.
 */
public EventSet remove(long timeout) throws InterruptedException {
    if (timeout < 0) {
        throw new IllegalArgumentException("Timeout cannot be negative");
    }

    EventSet eventSet;
    while (true) {
        EventSetImpl fullEventSet = removeUnfiltered(timeout);
        if (fullEventSet == null) {
            eventSet = null;  // timeout
            break;
        }
        /*
         * Remove events from the event set for which
         * there is no corresponding enabled request (
         * this includes our internally requested events.)
         * This never returns null
         */
        eventSet = fullEventSet.userFilter();
        if (!eventSet.isEmpty()) {
            break;
        }
    }

    if ((eventSet != null) && (eventSet.suspendPolicy() == JDWP.SuspendPolicy.ALL)) {
        vm.notifySuspend();
    }

    return eventSet;
}
 

protected void handleEventCmdSet(Packet p) {
    EventSet eventSet = new EventSetImpl(vm, p);

    if (eventSet != null) {
        queueEventSet(eventSet);
    }
}
 

private void queueEventSet(EventSet eventSet) {
    int maxQueueSize = 0;

    synchronized(eventQueues) {
        Iterator<EventQueue> iter = eventQueues.iterator();
        while (iter.hasNext()) {
            EventQueueImpl queue = (EventQueueImpl)iter.next();
            queue.enqueue(eventSet);
            maxQueueSize = Math.max(maxQueueSize, queue.size());
        }
    }

    controlEventFlow(maxQueueSize);
}
 

/**
 * Filter out events not for user's eyes.
 * Then filter out empty sets.
 */
public EventSet remove(long timeout) throws InterruptedException {
    if (timeout < 0) {
        throw new IllegalArgumentException("Timeout cannot be negative");
    }

    EventSet eventSet;
    while (true) {
        EventSetImpl fullEventSet = removeUnfiltered(timeout);
        if (fullEventSet == null) {
            eventSet = null;  // timeout
            break;
        }
        /*
         * Remove events from the event set for which
         * there is no corresponding enabled request (
         * this includes our internally requested events.)
         * This never returns null
         */
        eventSet = fullEventSet.userFilter();
        if (!eventSet.isEmpty()) {
            break;
        }
    }

    if ((eventSet != null) && (eventSet.suspendPolicy() == JDWP.SuspendPolicy.ALL)) {
        vm.notifySuspend();
    }

    return eventSet;
}
 

/**
 * Filter out events not for user's eyes.
 * Then filter out empty sets.
 */
public EventSet remove(long timeout) throws InterruptedException {
    if (timeout < 0) {
        throw new IllegalArgumentException("Timeout cannot be negative");
    }

    EventSet eventSet;
    while (true) {
        EventSetImpl fullEventSet = removeUnfiltered(timeout);
        if (fullEventSet == null) {
            eventSet = null;  // timeout
            break;
        }
        /*
         * Remove events from the event set for which
         * there is no corresponding enabled request (
         * this includes our internally requested events.)
         * This never returns null
         */
        eventSet = fullEventSet.userFilter();
        if (!eventSet.isEmpty()) {
            break;
        }
    }

    if ((eventSet != null) && (eventSet.suspendPolicy() == JDWP.SuspendPolicy.ALL)) {
        vm.notifySuspend();
    }

    return eventSet;
}
 

protected void handleEventCmdSet(Packet p) {
    EventSet eventSet = new EventSetImpl(vm, p);

    if (eventSet != null) {
        queueEventSet(eventSet);
    }
}
 

private void queueEventSet(EventSet eventSet) {
    int maxQueueSize = 0;

    synchronized(eventQueues) {
        Iterator<EventQueue> iter = eventQueues.iterator();
        while (iter.hasNext()) {
            EventQueueImpl queue = (EventQueueImpl)iter.next();
            queue.enqueue(eventSet);
            maxQueueSize = Math.max(maxQueueSize, queue.size());
        }
    }

    controlEventFlow(maxQueueSize);
}
 

protected void handleEventCmdSet(Packet p) {
    EventSet eventSet = new EventSetImpl(vm, p);

    if (eventSet != null) {
        queueEventSet(eventSet);
    }
}