feat(jdk8): move files to new folder to avoid resources compiled.

jdkSrc/jdk8/com/sun/tools/jdi/EventSetImpl.java

@@ -0,0 +1,879 @@
+/*
+ * Copyright (c) 1998, 2013, 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.event.*;
+import com.sun.jdi.request.*;
+
+import java.util.*;
+enum EventDestination {UNKNOWN_EVENT, INTERNAL_EVENT, CLIENT_EVENT};
+
+/*
+ * An EventSet is normally created by the transport reader thread when
+ * it reads a JDWP Composite command.  The constructor doesn't unpack
+ * the events contained in the Composite command and create EventImpls
+ * for them because that process might involve calling back into the back-end
+ * which should not be done by the transport reader thread.  Instead,
+ * the raw bytes of the packet are read and stored in the EventSet.
+ * The EventSet is then added to each EventQueue. When an EventSet is
+ * removed from an EventQueue, the EventSetImpl.build() method is called.
+ * This method reads the packet bytes and creates the actual EventImpl objects.
+ * build() also filters out events for our internal handler and puts them in
+ * their own EventSet.  This means that the EventImpls that are in the EventSet
+ * that is on the queues are all for client requests.
+ */
+public class EventSetImpl extends ArrayList<Event> implements EventSet {
+    private static final long serialVersionUID = -4857338819787924570L;
+    private VirtualMachineImpl vm; // we implement Mirror
+    private Packet pkt;
+    private byte suspendPolicy;
+    private EventSetImpl internalEventSet;
+
+    public String toString() {
+        String string = "event set, policy:" + suspendPolicy +
+                        ", count:" + this.size() + " = {";
+        boolean first = true;
+        for (Event event : this) {
+            if (!first) {
+                string += ", ";
+            }
+            string += event.toString();
+            first = false;
+        }
+        string += "}";
+        return string;
+    }
+
+    abstract class EventImpl extends MirrorImpl implements Event {
+
+        private final byte eventCmd;
+        private final int requestID;
+        // This is set only for client requests, not internal requests.
+        private final EventRequest request;
+
+        /**
+         * Constructor for events.
+         */
+        protected EventImpl(JDWP.Event.Composite.Events.EventsCommon evt,
+                            int requestID) {
+            super(EventSetImpl.this.vm);
+            this.eventCmd = evt.eventKind();
+            this.requestID = requestID;
+            EventRequestManagerImpl ermi = EventSetImpl.this.
+                vm.eventRequestManagerImpl();
+            this.request =  ermi.request(eventCmd, requestID);
+        }
+
+        /*
+         * Override superclass back to default equality
+         */
+        public boolean equals(Object obj) {
+            return this == obj;
+        }
+
+        public int hashCode() {
+            return System.identityHashCode(this);
+        }
+
+        /**
+         * Constructor for VM disconnected events.
+         */
+        protected EventImpl(byte eventCmd) {
+            super(EventSetImpl.this.vm);
+            this.eventCmd = eventCmd;
+            this.requestID = 0;
+            this.request = null;
+        }
+
+        public EventRequest request() {
+            return request;
+        }
+
+        int requestID() {
+            return requestID;
+        }
+
+        EventDestination destination() {
+            /*
+             * We need to decide if this event is for
+             * 1. an internal request
+             * 2. a client request that is no longer available, ie
+             *    it has been deleted, or disabled and re-enabled
+             *    which gives it a new ID.
+             * 3. a current client request that is disabled
+             * 4. a current enabled client request.
+             *
+             * We will filter this set into a set
+             * that contains only 1s for our internal queue
+             * and a set that contains only 4s for our client queue.
+             * If we get an EventSet that contains only 2 and 3
+             * then we have to resume it if it is not SUSPEND_NONE
+             * because no one else will.
+             */
+            if (requestID == 0) {
+                /* An unsolicited event.  These have traditionally
+                 * been treated as client events.
+                 */
+                return EventDestination.CLIENT_EVENT;
+            }
+
+            // Is this an event for a current client request?
+            if (request == null) {
+                // Nope.  Is it an event for an internal request?
+                EventRequestManagerImpl ermi = this.vm.getInternalEventRequestManager();
+                if (ermi.request(eventCmd, requestID) != null) {
+                    // Yep
+                    return EventDestination.INTERNAL_EVENT;
+                }
+                return EventDestination.UNKNOWN_EVENT;
+            }
+
+            // We found a client request
+            if (request.isEnabled()) {
+                return EventDestination.CLIENT_EVENT;
+            }
+            return EventDestination.UNKNOWN_EVENT;
+        }
+
+        abstract String eventName();
+
+        public String toString() {
+            return eventName();
+        }
+
+    }
+
+    abstract class ThreadedEventImpl extends EventImpl {
+        private ThreadReference thread;
+
+        ThreadedEventImpl(JDWP.Event.Composite.Events.EventsCommon evt,
+                          int requestID, ThreadReference thread) {
+            super(evt, requestID);
+            this.thread = thread;
+        }
+
+        public ThreadReference thread() {
+            return thread;
+        }
+
+        public String toString() {
+            return eventName() + " in thread " + thread.name();
+        }
+    }
+
+    abstract class LocatableEventImpl extends ThreadedEventImpl
+                                            implements Locatable {
+        private Location location;
+
+        LocatableEventImpl(JDWP.Event.Composite.Events.EventsCommon evt,
+                           int requestID,
+                           ThreadReference thread, Location location) {
+            super(evt, requestID, thread);
+            this.location = location;
+        }
+
+        public Location location() {
+            return location;
+        }
+
+        /**
+         * For MethodEntry and MethodExit
+         */
+        public Method method() {
+            return location.method();
+        }
+
+        public String toString() {
+            return eventName() + "@" +
+                   ((location() == null) ? " null" : location().toString()) +
+                   " in thread " + thread().name();
+        }
+    }
+
+    class BreakpointEventImpl extends LocatableEventImpl
+                            implements BreakpointEvent {
+        BreakpointEventImpl(JDWP.Event.Composite.Events.Breakpoint evt) {
+            super(evt, evt.requestID, evt.thread, evt.location);
+        }
+
+        String eventName() {
+            return "BreakpointEvent";
+        }
+    }
+
+    class StepEventImpl extends LocatableEventImpl implements StepEvent {
+        StepEventImpl(JDWP.Event.Composite.Events.SingleStep evt) {
+            super(evt, evt.requestID, evt.thread, evt.location);
+        }
+
+        String eventName() {
+            return "StepEvent";
+        }
+    }
+
+    class MethodEntryEventImpl extends LocatableEventImpl
+                            implements MethodEntryEvent {
+        MethodEntryEventImpl(JDWP.Event.Composite.Events.MethodEntry evt) {
+            super(evt, evt.requestID, evt.thread, evt.location);
+        }
+
+        String eventName() {
+            return "MethodEntryEvent";
+        }
+    }
+
+    class MethodExitEventImpl extends LocatableEventImpl
+                            implements MethodExitEvent {
+        private Value returnVal = null;
+
+        MethodExitEventImpl(JDWP.Event.Composite.Events.MethodExit evt) {
+            super(evt, evt.requestID, evt.thread, evt.location);
+        }
+
+        MethodExitEventImpl(JDWP.Event.Composite.Events.MethodExitWithReturnValue evt) {
+            super(evt, evt.requestID, evt.thread, evt.location);
+            returnVal = evt.value;
+        }
+
+        String eventName() {
+            return "MethodExitEvent";
+        }
+
+        public Value returnValue() {
+            if (!this.vm.canGetMethodReturnValues()) {
+                throw new UnsupportedOperationException(
+                "target does not support return values in MethodExit events");
+            }
+            return returnVal;
+        }
+
+    }
+
+    class MonitorContendedEnterEventImpl extends LocatableEventImpl
+                            implements MonitorContendedEnterEvent {
+        private ObjectReference monitor = null;
+
+        MonitorContendedEnterEventImpl(JDWP.Event.Composite.Events.MonitorContendedEnter evt) {
+            super(evt, evt.requestID, evt.thread, evt.location);
+            this.monitor = evt.object;
+        }
+
+        String eventName() {
+            return "MonitorContendedEnter";
+        }
+
+        public ObjectReference  monitor() {
+            return monitor;
+        };
+
+    }
+
+    class MonitorContendedEnteredEventImpl extends LocatableEventImpl
+                            implements MonitorContendedEnteredEvent {
+        private ObjectReference monitor = null;
+
+        MonitorContendedEnteredEventImpl(JDWP.Event.Composite.Events.MonitorContendedEntered evt) {
+            super(evt, evt.requestID, evt.thread, evt.location);
+            this.monitor = evt.object;
+        }
+
+        String eventName() {
+            return "MonitorContendedEntered";
+        }
+
+        public ObjectReference  monitor() {
+            return monitor;
+        };
+
+    }
+
+    class MonitorWaitEventImpl extends LocatableEventImpl
+                            implements MonitorWaitEvent {
+        private ObjectReference monitor = null;
+        private long timeout;
+
+        MonitorWaitEventImpl(JDWP.Event.Composite.Events.MonitorWait evt) {
+            super(evt, evt.requestID, evt.thread, evt.location);
+            this.monitor = evt.object;
+            this.timeout = evt.timeout;
+        }
+
+        String eventName() {
+            return "MonitorWait";
+        }
+
+        public ObjectReference  monitor() {
+            return monitor;
+        };
+
+        public long timeout() {
+            return timeout;
+        }
+    }
+
+    class MonitorWaitedEventImpl extends LocatableEventImpl
+                            implements MonitorWaitedEvent {
+        private ObjectReference monitor = null;
+        private boolean timed_out;
+
+        MonitorWaitedEventImpl(JDWP.Event.Composite.Events.MonitorWaited evt) {
+            super(evt, evt.requestID, evt.thread, evt.location);
+            this.monitor = evt.object;
+            this.timed_out = evt.timed_out;
+        }
+
+        String eventName() {
+            return "MonitorWaited";
+        }
+
+        public ObjectReference  monitor() {
+            return monitor;
+        };
+
+        public boolean timedout() {
+            return timed_out;
+        }
+    }
+
+    class ClassPrepareEventImpl extends ThreadedEventImpl
+                            implements ClassPrepareEvent {
+        private ReferenceType referenceType;
+
+        ClassPrepareEventImpl(JDWP.Event.Composite.Events.ClassPrepare evt) {
+            super(evt, evt.requestID, evt.thread);
+            referenceType = this.vm.referenceType(evt.typeID, evt.refTypeTag,
+                                                  evt.signature);
+            ((ReferenceTypeImpl)referenceType).setStatus(evt.status);
+        }
+
+        public ReferenceType referenceType() {
+            return referenceType;
+        }
+
+        String eventName() {
+            return "ClassPrepareEvent";
+        }
+    }
+
+    class ClassUnloadEventImpl extends EventImpl implements ClassUnloadEvent {
+        private String classSignature;
+
+        ClassUnloadEventImpl(JDWP.Event.Composite.Events.ClassUnload evt) {
+            super(evt, evt.requestID);
+            this.classSignature = evt.signature;
+        }
+
+        public String className() {
+            return classSignature.substring(1, classSignature.length()-1)
+                .replace('/', '.');
+        }
+
+        public String classSignature() {
+            return classSignature;
+        }
+
+        String eventName() {
+            return "ClassUnloadEvent";
+        }
+    }
+
+    class ExceptionEventImpl extends LocatableEventImpl
+                                             implements ExceptionEvent {
+        private ObjectReference exception;
+        private Location catchLocation;
+
+        ExceptionEventImpl(JDWP.Event.Composite.Events.Exception evt) {
+            super(evt, evt.requestID, evt.thread, evt.location);
+            this.exception = evt.exception;
+            this.catchLocation = evt.catchLocation;
+        }
+
+        public ObjectReference exception() {
+            return exception;
+        }
+
+        public Location catchLocation() {
+            return catchLocation;
+        }
+
+        String eventName() {
+            return "ExceptionEvent";
+        }
+    }
+
+    class ThreadDeathEventImpl extends ThreadedEventImpl
+                                        implements ThreadDeathEvent {
+        ThreadDeathEventImpl(JDWP.Event.Composite.Events.ThreadDeath evt) {
+            super(evt, evt.requestID, evt.thread);
+        }
+
+        String eventName() {
+            return "ThreadDeathEvent";
+        }
+    }
+
+    class ThreadStartEventImpl extends ThreadedEventImpl
+                                        implements ThreadStartEvent {
+        ThreadStartEventImpl(JDWP.Event.Composite.Events.ThreadStart evt) {
+            super(evt, evt.requestID, evt.thread);
+        }
+
+        String eventName() {
+            return "ThreadStartEvent";
+        }
+    }
+
+    class VMStartEventImpl extends ThreadedEventImpl
+                                        implements VMStartEvent {
+        VMStartEventImpl(JDWP.Event.Composite.Events.VMStart evt) {
+            super(evt, evt.requestID, evt.thread);
+        }
+
+        String eventName() {
+            return "VMStartEvent";
+        }
+    }
+
+    class VMDeathEventImpl extends EventImpl implements VMDeathEvent {
+
+        VMDeathEventImpl(JDWP.Event.Composite.Events.VMDeath evt) {
+            super(evt, evt.requestID);
+        }
+
+        String eventName() {
+            return "VMDeathEvent";
+        }
+    }
+
+    class VMDisconnectEventImpl extends EventImpl
+                                         implements VMDisconnectEvent {
+
+        VMDisconnectEventImpl() {
+            super((byte)JDWP.EventKind.VM_DISCONNECTED);
+        }
+
+        String eventName() {
+            return "VMDisconnectEvent";
+        }
+    }
+
+    abstract class WatchpointEventImpl extends LocatableEventImpl
+                                            implements WatchpointEvent {
+        private final ReferenceTypeImpl refType;
+        private final long fieldID;
+        private final ObjectReference object;
+        private Field field = null;
+
+        WatchpointEventImpl(JDWP.Event.Composite.Events.EventsCommon evt,
+                            int requestID,
+                            ThreadReference thread, Location location,
+                            byte refTypeTag, long typeID, long fieldID,
+                            ObjectReference object) {
+            super(evt, requestID, thread, location);
+            this.refType = this.vm.referenceType(typeID, refTypeTag);
+            this.fieldID = fieldID;
+            this.object = object;
+        }
+
+        public Field field() {
+            if (field == null) {
+                field = refType.getFieldMirror(fieldID);
+            }
+            return field;
+        }
+
+        public ObjectReference object() {
+            return object;
+        }
+
+        public Value valueCurrent() {
+            if (object == null) {
+                return refType.getValue(field());
+            } else {
+                return object.getValue(field());
+            }
+        }
+    }
+
+    class AccessWatchpointEventImpl extends WatchpointEventImpl
+                                            implements AccessWatchpointEvent {
+
+        AccessWatchpointEventImpl(JDWP.Event.Composite.Events.FieldAccess evt) {
+            super(evt, evt.requestID, evt.thread, evt.location,
+                  evt.refTypeTag, evt.typeID, evt.fieldID, evt.object);
+        }
+
+        String eventName() {
+            return "AccessWatchpoint";
+        }
+    }
+
+    class ModificationWatchpointEventImpl extends WatchpointEventImpl
+                           implements ModificationWatchpointEvent {
+        Value newValue;
+
+        ModificationWatchpointEventImpl(
+                        JDWP.Event.Composite.Events.FieldModification evt) {
+            super(evt, evt.requestID, evt.thread, evt.location,
+                  evt.refTypeTag, evt.typeID, evt.fieldID, evt.object);
+            this.newValue = evt.valueToBe;
+        }
+
+        public Value valueToBe() {
+            return newValue;
+        }
+
+        String eventName() {
+            return "ModificationWatchpoint";
+        }
+    }
+
+    /**
+     * Events are constructed on the thread which reads all data from the
+     * transport. This means that the packet cannot be converted to real
+     * JDI objects as that may involve further communications with the
+     * back end which would deadlock.
+     *
+     * Hence the {@link #build()} method below called by EventQueue.
+     */
+    EventSetImpl(VirtualMachine aVm, Packet pkt) {
+        super();
+
+        // From "MirrorImpl":
+        // Yes, its a bit of a hack. But by doing it this
+        // way, this is the only place we have to change
+        // typing to substitute a new impl.
+        vm = (VirtualMachineImpl)aVm;
+
+        this.pkt = pkt;
+    }
+
+    /**
+     * Constructor for special events like VM disconnected
+     */
+    EventSetImpl(VirtualMachine aVm, byte eventCmd) {
+        this(aVm, null);
+        suspendPolicy = JDWP.SuspendPolicy.NONE;
+        switch (eventCmd) {
+            case JDWP.EventKind.VM_DISCONNECTED:
+                addEvent(new VMDisconnectEventImpl());
+                break;
+
+            default:
+                throw new InternalException("Bad singleton event code");
+        }
+    }
+
+    private void addEvent(EventImpl evt) {
+        // Note that this class has a public add method that throws
+        // an exception so that clients can't modify the EventSet
+        super.add(evt);
+    }
+
+    /*
+     * Complete the construction of an EventSet.  This is called from
+     * an event handler thread.  It upacks the JDWP events inside
+     * the packet and creates EventImpls for them.  The EventSet is already
+     * on EventQueues when this is called, so it has to be synch.
+     */
+    synchronized void build() {
+        if (pkt == null) {
+            return;
+        }
+        PacketStream ps = new PacketStream(vm, pkt);
+        JDWP.Event.Composite compEvt = new JDWP.Event.Composite(vm, ps);
+        suspendPolicy = compEvt.suspendPolicy;
+        if ((vm.traceFlags & VirtualMachine.TRACE_EVENTS) != 0) {
+            switch(suspendPolicy) {
+                case JDWP.SuspendPolicy.ALL:
+                    vm.printTrace("EventSet: SUSPEND_ALL");
+                    break;
+
+                case JDWP.SuspendPolicy.EVENT_THREAD:
+                    vm.printTrace("EventSet: SUSPEND_EVENT_THREAD");
+                    break;
+
+                case JDWP.SuspendPolicy.NONE:
+                    vm.printTrace("EventSet: SUSPEND_NONE");
+                    break;
+            }
+        }
+
+        ThreadReference fix6485605 = null;
+        for (int i = 0; i < compEvt.events.length; i++) {
+            EventImpl evt = createEvent(compEvt.events[i]);
+            if ((vm.traceFlags & VirtualMachine.TRACE_EVENTS) != 0) {
+                try {
+                    vm.printTrace("Event: " + evt);
+                } catch (VMDisconnectedException ee) {
+                    // ignore - see bug 6502716
+                }
+            }
+
+            switch (evt.destination()) {
+                case UNKNOWN_EVENT:
+                    // Ignore disabled, deleted, unknown events, but
+                    // save the thread if there is one since we might
+                    // have to resume it.  Note that events for different
+                    // threads can't be in the same event set.
+                    if (evt instanceof ThreadedEventImpl &&
+                        suspendPolicy == JDWP.SuspendPolicy.EVENT_THREAD) {
+                        fix6485605 = ((ThreadedEventImpl)evt).thread();
+                    }
+                    continue;
+                case CLIENT_EVENT:
+                    addEvent(evt);
+                    break;
+                case INTERNAL_EVENT:
+                    if (internalEventSet == null) {
+                        internalEventSet = new EventSetImpl(this.vm, null);
+                    }
+                    internalEventSet.addEvent(evt);
+                    break;
+                default:
+                    throw new InternalException("Invalid event destination");
+            }
+        }
+        pkt = null; // No longer needed - free it up
+
+        // Avoid hangs described in 6296125, 6293795
+        if (super.size() == 0) {
+            // This set has no client events.  If we don't do
+            // needed resumes, no one else is going to.
+            if (suspendPolicy == JDWP.SuspendPolicy.ALL) {
+                vm.resume();
+            } else if (suspendPolicy == JDWP.SuspendPolicy.EVENT_THREAD) {
+                // See bug 6485605.
+                if (fix6485605 != null) {
+                    fix6485605.resume();
+                } else {
+                    // apparently, there is nothing to resume.
+                }
+            }
+            suspendPolicy = JDWP.SuspendPolicy.NONE;
+
+        }
+
+    }
+
+    /**
+     * Filter out internal events
+     */
+    EventSet userFilter() {
+        return this;
+    }
+
+    /**
+     * Filter out user events.
+     */
+    EventSet internalFilter() {
+        return this.internalEventSet;
+    }
+
+    EventImpl createEvent(JDWP.Event.Composite.Events evt) {
+        JDWP.Event.Composite.Events.EventsCommon comm = evt.aEventsCommon;
+        switch (evt.eventKind) {
+            case JDWP.EventKind.THREAD_START:
+                return new ThreadStartEventImpl(
+                      (JDWP.Event.Composite.Events.ThreadStart)comm);
+
+            case JDWP.EventKind.THREAD_END:
+                return new ThreadDeathEventImpl(
+                      (JDWP.Event.Composite.Events.ThreadDeath)comm);
+
+            case JDWP.EventKind.EXCEPTION:
+                return new ExceptionEventImpl(
+                      (JDWP.Event.Composite.Events.Exception)comm);
+
+            case JDWP.EventKind.BREAKPOINT:
+                return new BreakpointEventImpl(
+                      (JDWP.Event.Composite.Events.Breakpoint)comm);
+
+            case JDWP.EventKind.METHOD_ENTRY:
+                return new MethodEntryEventImpl(
+                      (JDWP.Event.Composite.Events.MethodEntry)comm);
+
+            case JDWP.EventKind.METHOD_EXIT:
+                return new MethodExitEventImpl(
+                      (JDWP.Event.Composite.Events.MethodExit)comm);
+
+            case JDWP.EventKind.METHOD_EXIT_WITH_RETURN_VALUE:
+                return new MethodExitEventImpl(
+                      (JDWP.Event.Composite.Events.MethodExitWithReturnValue)comm);
+
+            case JDWP.EventKind.FIELD_ACCESS:
+                return new AccessWatchpointEventImpl(
+                      (JDWP.Event.Composite.Events.FieldAccess)comm);
+
+            case JDWP.EventKind.FIELD_MODIFICATION:
+                return new ModificationWatchpointEventImpl(
+                      (JDWP.Event.Composite.Events.FieldModification)comm);
+
+            case JDWP.EventKind.SINGLE_STEP:
+                return new StepEventImpl(
+                      (JDWP.Event.Composite.Events.SingleStep)comm);
+
+            case JDWP.EventKind.CLASS_PREPARE:
+                return new ClassPrepareEventImpl(
+                      (JDWP.Event.Composite.Events.ClassPrepare)comm);
+
+            case JDWP.EventKind.CLASS_UNLOAD:
+                return new ClassUnloadEventImpl(
+                      (JDWP.Event.Composite.Events.ClassUnload)comm);
+
+            case JDWP.EventKind.MONITOR_CONTENDED_ENTER:
+                return new MonitorContendedEnterEventImpl(
+                      (JDWP.Event.Composite.Events.MonitorContendedEnter)comm);
+
+            case JDWP.EventKind.MONITOR_CONTENDED_ENTERED:
+                return new MonitorContendedEnteredEventImpl(
+                      (JDWP.Event.Composite.Events.MonitorContendedEntered)comm);
+
+            case JDWP.EventKind.MONITOR_WAIT:
+                return new MonitorWaitEventImpl(
+                      (JDWP.Event.Composite.Events.MonitorWait)comm);
+
+            case JDWP.EventKind.MONITOR_WAITED:
+                return new MonitorWaitedEventImpl(
+                      (JDWP.Event.Composite.Events.MonitorWaited)comm);
+
+            case JDWP.EventKind.VM_START:
+                return new VMStartEventImpl(
+                      (JDWP.Event.Composite.Events.VMStart)comm);
+
+            case JDWP.EventKind.VM_DEATH:
+                return new VMDeathEventImpl(
+                      (JDWP.Event.Composite.Events.VMDeath)comm);
+
+            default:
+                // Ignore unknown event types
+                System.err.println("Ignoring event cmd " +
+                                   evt.eventKind + " from the VM");
+                return null;
+        }
+    }
+
+    public VirtualMachine virtualMachine() {
+        return vm;
+    }
+
+    public int suspendPolicy() {
+        return EventRequestManagerImpl.JDWPtoJDISuspendPolicy(suspendPolicy);
+    }
+
+    private ThreadReference eventThread() {
+        for (Event event : this) {
+            if (event instanceof ThreadedEventImpl) {
+                return ((ThreadedEventImpl)event).thread();
+            }
+        }
+        return null;
+    }
+
+    public void resume() {
+        switch (suspendPolicy()) {
+            case EventRequest.SUSPEND_ALL:
+                vm.resume();
+                break;
+            case EventRequest.SUSPEND_EVENT_THREAD:
+                ThreadReference thread = eventThread();
+                if (thread == null) {
+                    throw new InternalException("Inconsistent suspend policy");
+                }
+                thread.resume();
+                break;
+            case EventRequest.SUSPEND_NONE:
+                // Do nothing
+                break;
+            default:
+                throw new InternalException("Invalid suspend policy");
+        }
+    }
+
+    public Iterator<Event> iterator() {
+        return new Itr();
+    }
+
+    public EventIterator eventIterator() {
+        return new Itr();
+    }
+
+    public class Itr implements EventIterator {
+        /**
+         * Index of element to be returned by subsequent call to next.
+         */
+        int cursor = 0;
+
+        public boolean hasNext() {
+            return cursor != size();
+        }
+
+        public Event next() {
+            try {
+                Event nxt = get(cursor);
+                ++cursor;
+                return nxt;
+            } catch(IndexOutOfBoundsException e) {
+                throw new NoSuchElementException();
+            }
+        }
+
+        public Event nextEvent() {
+            return next();
+        }
+
+        public void remove() {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    @Override
+    public Spliterator<Event> spliterator() {
+        return Spliterators.spliterator(this, Spliterator.DISTINCT);
+    }
+
+    /* below make this unmodifiable */
+
+    public boolean add(Event o){
+        throw new UnsupportedOperationException();
+    }
+    public boolean remove(Object o) {
+        throw new UnsupportedOperationException();
+    }
+    public boolean addAll(Collection<? extends Event> coll) {
+        throw new UnsupportedOperationException();
+    }
+    public boolean removeAll(Collection<?> coll) {
+        throw new UnsupportedOperationException();
+    }
+    public boolean retainAll(Collection<?> coll) {
+        throw new UnsupportedOperationException();
+    }
+    public void clear() {
+        throw new UnsupportedOperationException();
+    }
+}