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: /** A class providing static methods and objects that do useful things with indirect priority queues.
028: *
029: * @see IndirectDoublePriorityQueue
030: */
031:
032: public class IndirectDoublePriorityQueues {
033:
034: private IndirectDoublePriorityQueues() {
035: }
036:
037: /** An immutable class representing the empty indirect double priority queue.
038: *
039: * <P>This class may be useful to implement your own in case you subclass
040: * {@link IndirectDoublePriorityQueue}.
041: */
042:
043: @SuppressWarnings("unchecked")
044: public static class EmptyIndirectDoublePriorityQueue extends
045: IndirectPriorityQueues.EmptyIndirectPriorityQueue {
046:
047: protected EmptyIndirectDoublePriorityQueue() {
048: }
049:
050: public int secondaryFirst() {
051: throw new NoSuchElementException();
052: }
053:
054: public int secondaryLast() {
055: throw new NoSuchElementException();
056: }
057:
058: public Comparator secondaryComparator() {
059: return null;
060: }
061:
062: }
063:
064: /** An empty indirect double priority queue (immutable).
065: */
066:
067: public final static EmptyIndirectDoublePriorityQueue EMPTY_QUEUE = new EmptyIndirectDoublePriorityQueue();
068:
069: /** A synchronized wrapper class for indirect double priority queues. */
070:
071: public static class SynchronizedIndirectDoublePriorityQueue<K>
072: implements IndirectDoublePriorityQueue<K> {
073:
074: public static final long serialVersionUID = -7046029254386353129L;
075:
076: final protected IndirectDoublePriorityQueue<K> q;
077: final protected Object sync;
078:
079: protected SynchronizedIndirectDoublePriorityQueue(
080: final IndirectDoublePriorityQueue<K> q,
081: final Object sync) {
082: this .q = q;
083: this .sync = sync;
084: }
085:
086: protected SynchronizedIndirectDoublePriorityQueue(
087: final IndirectDoublePriorityQueue<K> q) {
088: this .q = q;
089: this .sync = this ;
090: }
091:
092: public void enqueue(int x) {
093: synchronized (sync) {
094: q.enqueue(x);
095: }
096: }
097:
098: public int dequeue() {
099: synchronized (sync) {
100: return q.dequeue();
101: }
102: }
103:
104: public int first() {
105: synchronized (sync) {
106: return q.first();
107: }
108: }
109:
110: public int last() {
111: synchronized (sync) {
112: return q.last();
113: }
114: }
115:
116: public int secondaryFirst() {
117: synchronized (sync) {
118: return q.secondaryFirst();
119: }
120: }
121:
122: public int secondaryLast() {
123: synchronized (sync) {
124: return q.secondaryLast();
125: }
126: }
127:
128: public boolean isEmpty() {
129: synchronized (sync) {
130: return q.isEmpty();
131: }
132: }
133:
134: public int size() {
135: synchronized (sync) {
136: return q.size();
137: }
138: }
139:
140: public void clear() {
141: synchronized (sync) {
142: q.clear();
143: }
144: }
145:
146: public void changed() {
147: synchronized (sync) {
148: q.changed();
149: }
150: }
151:
152: public void allChanged() {
153: synchronized (sync) {
154: q.allChanged();
155: }
156: }
157:
158: public void changed(int i) {
159: synchronized (sync) {
160: q.changed(i);
161: }
162: }
163:
164: public void remove(int i) {
165: synchronized (sync) {
166: q.remove(i);
167: }
168: }
169:
170: public Comparator<? super K> comparator() {
171: synchronized (sync) {
172: return q.comparator();
173: }
174: }
175:
176: public Comparator<? super K> secondaryComparator() {
177: synchronized (sync) {
178: return q.secondaryComparator();
179: }
180: }
181:
182: public int secondaryFront(int[] a) {
183: return q.secondaryFront(a);
184: }
185:
186: public int front(int[] a) {
187: return q.front(a);
188: }
189: }
190:
191: /** Returns a synchronized type-specific indirect double priority queue backed by the specified type-specific indirect double priority queue.
192: *
193: * @param q the indirect double priority queue to be wrapped in a synchronized indirect double priority queue.
194: * @return a synchronized view of the specified indirect double priority queue.
195: */
196: public static <K> IndirectDoublePriorityQueue<K> synchronize(
197: final IndirectDoublePriorityQueue<K> q) {
198: return new SynchronizedIndirectDoublePriorityQueue<K>(q);
199: }
200:
201: /** Returns a synchronized type-specific indirect double priority queue backed by the specified type-specific indirect double priority queue, using an assigned object to synchronize.
202: *
203: * @param q the indirect double priority queue to be wrapped in a synchronized indirect double priority queue.
204: * @param sync an object that will be used to synchronize the access to the indirect double priority queue.
205: * @return a synchronized view of the specified indirect double priority queue.
206: */
207:
208: public static <K> IndirectDoublePriorityQueue<K> synchronize(
209: final IndirectDoublePriorityQueue<K> q, final Object sync) {
210: return new SynchronizedIndirectDoublePriorityQueue<K>(q, sync);
211: }
212:
213: }
|