source: trunk/src/org/expeditee/gio/TimeoutQueue.java@ 1097

package org.expeditee.gio;

import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.PriorityQueue;

public class TimeoutQueue {
        
        private PriorityQueue<Long> _timeoutQueue;
        
        private HashSet<TimeoutHandle> _cancelledTimeouts;
        
        private HashMap<TimeoutHandle, Long> _timeoutHandleMap;
        
        private HashMap<Long, HashSet<TimeoutHandle>> _timeoutMap;
        
        public TimeoutQueue()
        {
                _timeoutQueue = new PriorityQueue<Long>();
                _cancelledTimeouts = new HashSet<TimeoutHandle>();
                _timeoutHandleMap = new HashMap<TimeoutHandle, Long>();
                _timeoutMap = new HashMap<Long, HashSet<TimeoutHandle>>();
        }
        
        public TimeoutHandle addTimeout(long milliseconds)
        {
                if (milliseconds < 0) return null;
                
                milliseconds += System.currentTimeMillis();
                
                TimeoutHandle handle = new TimeoutHandle();
                
                _timeoutQueue.add(milliseconds);
                _timeoutHandleMap.put(handle, milliseconds);
                if (!_timeoutMap.containsKey(milliseconds)) {
                        _timeoutMap.put(milliseconds, new HashSet<TimeoutHandle>());
                }
                _timeoutMap.get(milliseconds).add(handle);
                
                return handle;
        }
        
        public void cancelTimeout(TimeoutHandle handle)
        {
                if (handle == null) return;
                
                if (!_timeoutHandleMap.containsKey(handle)) return;
                
                _cancelledTimeouts.add(handle);
        }
        
        public Long getNextTimeout()
        {
                while (!_timeoutQueue.isEmpty()) {
                        long nextTimeout = _timeoutQueue.peek();
                        HashSet<TimeoutHandle> handlesForNextTimeout = handlesForTimeout(nextTimeout);
                        if (handlesAreCancelled(handlesForNextTimeout)) {
                                _timeoutQueue.poll();
                                _timeoutMap.remove(nextTimeout);
                                _cancelledTimeouts.removeAll(handlesForNextTimeout);
                                for (TimeoutHandle handle : handlesForNextTimeout) _timeoutHandleMap.remove(handle);
                        } else {
                                return nextTimeout - System.currentTimeMillis();
                        }
                }
                
                // No valid timeout found
                return null;
        }
        
        public HashSet<TimeoutHandle> popExpiredTimeouts()
        {
                HashSet<TimeoutHandle> ret = new HashSet<TimeoutHandle>();
                
                while (!_timeoutQueue.isEmpty()) {
                        long nextTimeout = _timeoutQueue.peek();
                        long nextTimeoutRelative = nextTimeout - System.currentTimeMillis();
                        if (nextTimeoutRelative > 0) break;
                        HashSet<TimeoutHandle> handlesForNextTimeout = popNextTimeout();
                        ret.addAll(handlesForNextTimeout);
                }
                
                return ret;
        }
        
        private boolean handlesAreCancelled(Collection<TimeoutHandle> handles)
        {
                if (handles == null) return false;
                
                return _cancelledTimeouts.containsAll(handles);
        }
        
        private boolean handleIsCancelled(TimeoutHandle handle)
        {
                if (handle == null) return false;
                
                return _cancelledTimeouts.contains(handle);
        }
        
        private HashSet<TimeoutHandle> handlesForTimeout(long timeout)
        {
                if (!_timeoutMap.containsKey(timeout)) return null;
                
                return _timeoutMap.get(timeout);
        }
        
        private HashSet<TimeoutHandle> popNextTimeout()
        {
                if (_timeoutQueue.isEmpty()) return null;
                
                long nextTimeout = _timeoutQueue.poll();
                HashSet<TimeoutHandle> handlesForNextTimeout = handlesForTimeout(nextTimeout);
                _timeoutMap.remove(nextTimeout);
                for (TimeoutHandle handle : handlesForNextTimeout) {
                        if (handleIsCancelled(handle)) {
                                handlesForNextTimeout.remove(handle);
                                _cancelledTimeouts.remove(handle);
                        }
                        _timeoutHandleMap.remove(handle);
                }
                
                return handlesForNextTimeout;
        }
        
        public static class TimeoutHandle {

                private static long _nextHandle = 1;

                private static long getNextHandle()
                {
                        long ret = _nextHandle;
                        _nextHandle++;
                        return ret;
                }
                
                private long _handle;
                
                public TimeoutHandle()
                {
                        _handle = getNextHandle();
                }
                
                public long getHandle()
                {
                        return _handle;
                }
        }
        
}