001: package it.unimi.dsi.fastutil;
002:
003: /*
004: * fastutil: Fast & compact type-specific collections for Java
005: *
006: * Copyright (C) 2003-2008 Sebastiano Vigna
007: *
008: * This library is free software; you can redistribute it and/or
009: * modify it under the terms of the GNU Lesser General Public
010: * License as published by the Free Software Foundation; either
011: * version 2.1 of the License, or (at your option) any later version.
012: *
013: * This library is distributed in the hope that it will be useful,
014: * but WITHOUT ANY WARRANTY; without even the implied warranty of
015: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
016: * Lesser General Public License for more details.
017: *
018: * You should have received a copy of the GNU Lesser General Public
019: * License along with this library; if not, write to the Free Software
020: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
021: *
022: */
023:
024: import java.util.Comparator;
025: import java.util.NoSuchElementException;
026:
027: import it.unimi.dsi.fastutil.PriorityQueue;
028:
029: /** A class providing static methods and objects that do useful things with priority queues.
030: *
031: * @see it.unimi.dsi.fastutil.PriorityQueue
032: */
033:
034: public class PriorityQueues {
035:
036: private PriorityQueues() {
037: }
038:
039: /** An immutable class representing the empty priority queue.
040: *
041: * <P>This class may be useful to implement your own in case you subclass
042: * {@link PriorityQueue}.
043: */
044:
045: @SuppressWarnings("unchecked")
046: public static class EmptyPriorityQueue extends
047: AbstractPriorityQueue {
048:
049: protected EmptyPriorityQueue() {
050: }
051:
052: public void enqueue(Object o) {
053: throw new UnsupportedOperationException();
054: }
055:
056: public Object dequeue() {
057: throw new NoSuchElementException();
058: }
059:
060: public boolean isEmpty() {
061: return true;
062: }
063:
064: public int size() {
065: return 0;
066: }
067:
068: public void clear() {
069: }
070:
071: public Object first() {
072: throw new NoSuchElementException();
073: }
074:
075: public Object last() {
076: throw new NoSuchElementException();
077: }
078:
079: public void changed() {
080: throw new NoSuchElementException();
081: }
082:
083: public Comparator comparator() {
084: return null;
085: }
086:
087: }
088:
089: /** An empty indirect priority queue (immutable).
090: */
091:
092: public final static EmptyPriorityQueue EMPTY_QUEUE = new EmptyPriorityQueue();
093:
094: /** A synchronized wrapper class for priority queues. */
095:
096: public static class SynchronizedPriorityQueue<K> implements
097: PriorityQueue<K> {
098:
099: public static final long serialVersionUID = -7046029254386353129L;
100:
101: final protected PriorityQueue<K> q;
102: final protected Object sync;
103:
104: protected SynchronizedPriorityQueue(final PriorityQueue<K> q,
105: final Object sync) {
106: this .q = q;
107: this .sync = sync;
108: }
109:
110: protected SynchronizedPriorityQueue(final PriorityQueue<K> q) {
111: this .q = q;
112: this .sync = this ;
113: }
114:
115: public void enqueue(K x) {
116: synchronized (sync) {
117: q.enqueue(x);
118: }
119: }
120:
121: public K dequeue() {
122: synchronized (sync) {
123: return q.dequeue();
124: }
125: }
126:
127: public K first() {
128: synchronized (sync) {
129: return q.first();
130: }
131: }
132:
133: public K last() {
134: synchronized (sync) {
135: return q.last();
136: }
137: }
138:
139: public boolean isEmpty() {
140: synchronized (sync) {
141: return q.isEmpty();
142: }
143: }
144:
145: public int size() {
146: synchronized (sync) {
147: return q.size();
148: }
149: }
150:
151: public void clear() {
152: synchronized (sync) {
153: q.clear();
154: }
155: }
156:
157: public void changed() {
158: synchronized (sync) {
159: q.changed();
160: }
161: }
162:
163: public Comparator<? super K> comparator() {
164: synchronized (sync) {
165: return q.comparator();
166: }
167: }
168: }
169:
170: /** Returns a synchronized priority queue backed by the specified priority queue.
171: *
172: * @param q the priority queue to be wrapped in a synchronized priority queue.
173: * @return a synchronized view of the specified priority queue.
174: */
175: public static <K> PriorityQueue<K> synchronize(
176: final PriorityQueue<K> q) {
177: return new SynchronizedPriorityQueue<K>(q);
178: }
179:
180: /** Returns a synchronized priority queue backed by the specified priority queue, using an assigned object to synchronize.
181: *
182: * @param q the priority queue to be wrapped in a synchronized priority queue.
183: * @param sync an object that will be used to synchronize the access to the priority queue.
184: * @return a synchronized view of the specified priority queue.
185: */
186:
187: public static <K> PriorityQueue<K> synchronize(
188: final PriorityQueue<K> q, final Object sync) {
189: return new SynchronizedPriorityQueue<K>(q, sync);
190: }
191: }
|