Add FloatPriorityQueueView

src/main/java/org/warp/commonutils/type/FloatPriorityQueue.java

@@ -285,6 +285,10 @@ public class FloatPriorityQueue<T> implements Queue<T> {
 		return internalQueue.stream();
 	}
 
+	public <U extends T> FloatPriorityQueueView<U> view() {
+		return new FloatPriorityQueueView<U>(this);
+	}
+
 	private static class SynchronizedFloatPriorityQueue<T> extends FloatPriorityQueue<T> {
 
 		public SynchronizedFloatPriorityQueue(Object2FloatMap<T> contentValues, Queue<ScoredValue<T>> internalQueue) {

src/main/java/org/warp/commonutils/type/FloatPriorityQueueView.java

@@ -0,0 +1,150 @@
+package org.warp.commonutils.type;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Queue;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.stream.Stream;
+import org.jetbrains.annotations.NotNull;
+
+@SuppressWarnings("unused")
+public class FloatPriorityQueueView<T> implements Queue<T> {
+
+	private final FloatPriorityQueue<? super T> queue;
+
+	public FloatPriorityQueueView(FloatPriorityQueue<? super T> queue) {
+		this.queue = queue;
+	}
+
+	public static <T> BiFunction<FloatPriorityQueueView<T>, FloatPriorityQueueView<T>, FloatPriorityQueueView<T>> aggregator() {
+		return (a, b) -> {
+			var fpq = new FloatPriorityQueue<>();
+			a.forEachItem(fpq::offer);
+			b.forEachItem(fpq::offer);
+			return new FloatPriorityQueueView<>(fpq);
+		};
+	}
+
+	public static <T> FloatPriorityQueueView<T> of() {
+		return new FloatPriorityQueueView<>(FloatPriorityQueue.of());
+	}
+
+	@Override
+	public int size() {
+		return queue.size();
+	}
+
+	@Override
+	public boolean isEmpty() {
+		return queue.isEmpty();
+	}
+
+	@Override
+	public boolean contains(Object o) {
+		return queue.contains(o);
+	}
+
+	@NotNull
+	@Override
+	public Iterator<T> iterator() {
+		var it = queue.iterator();
+		return new Iterator<>() {
+			@Override
+			public boolean hasNext() {
+				return it.hasNext();
+			}
+
+			@SuppressWarnings("unchecked")
+			@Override
+			public T next() {
+				return (T) it.next();
+			}
+		};
+	}
+
+	@NotNull
+	@Override
+	public Object[] toArray() {
+		return queue.toArray();
+	}
+
+	@NotNull
+	@Override
+	public <T1> T1[] toArray(@NotNull T1[] a) {
+		//noinspection SuspiciousToArrayCall
+		return queue.toArray(a);
+	}
+
+	@Override
+	public boolean containsAll(@NotNull Collection<?> c) {
+		return queue.containsAll(c);
+	}
+
+	@Override
+	public boolean addAll(@NotNull Collection<? extends T> c) {
+		throw new UnsupportedOperationException("Read-only");
+	}
+
+	@Override
+	public boolean removeAll(@NotNull Collection<?> c) {
+		throw new UnsupportedOperationException("Read-only");
+	}
+
+	@Override
+	public boolean retainAll(@NotNull Collection<?> c) {
+		throw new UnsupportedOperationException("Read-only");
+	}
+
+	@Override
+	public void clear() {
+		throw new UnsupportedOperationException("Read-only");
+	}
+
+	@Override
+	public boolean add(T t) {
+		throw new UnsupportedOperationException("Read-only");
+	}
+
+	@Override
+	public boolean remove(Object o) {
+		throw new UnsupportedOperationException("Read-only");
+	}
+
+	@Override
+	public boolean offer(T t) {
+		throw new UnsupportedOperationException("Read-only");
+	}
+
+	@Override
+	public T remove() {
+		throw new UnsupportedOperationException("Read-only");
+	}
+
+	@Override
+	public T poll() {
+		throw new UnsupportedOperationException("Read-only");
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public T element() {
+		return (T) queue.element();
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public T peek() {
+		return (T) queue.peek();
+	}
+
+	@SuppressWarnings("unchecked")
+	public void forEachItem(Consumer<ScoredValue<T>> action) {
+		queue.forEachItem((v) -> action.accept((ScoredValue<T>) v));
+	}
+
+	@SuppressWarnings("unchecked")
+	public Stream<ScoredValue<T>> streamItems() {
+		return queue.streamItems().map(t -> (ScoredValue<T>) t);
+	}
+}