mirror of
https://github.com/dmulloy2/ProtocolLib.git
synced 2024-06-30 08:44:42 +02:00
146 lines
5.1 KiB
Java
146 lines
5.1 KiB
Java
/*
|
|
* ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
|
|
* Copyright (C) 2012 Kristian S. Stangeland
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it under the terms of the
|
|
* GNU General Public License as published by the Free Software Foundation; either version 2 of
|
|
* the License, or (at your option) any later version.
|
|
*
|
|
* This program 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 for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with this program;
|
|
* if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
|
* 02111-1307 USA
|
|
*/
|
|
|
|
package com.comphenix.protocol.concurrency;
|
|
|
|
import com.comphenix.protocol.PacketType;
|
|
import com.comphenix.protocol.events.ListeningWhitelist;
|
|
import com.comphenix.protocol.injector.PrioritizedListener;
|
|
import com.google.common.collect.Iterables;
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
import java.util.concurrent.ConcurrentMap;
|
|
|
|
/**
|
|
* A thread-safe implementation of a listener multimap.
|
|
*
|
|
* @author Kristian
|
|
*/
|
|
public abstract class AbstractConcurrentListenerMultimap<T> {
|
|
|
|
// The core of our map
|
|
private final ConcurrentMap<PacketType, SortedCopyOnWriteArray<PrioritizedListener<T>>> mapListeners;
|
|
|
|
protected AbstractConcurrentListenerMultimap() {
|
|
this.mapListeners = new ConcurrentHashMap<>();
|
|
}
|
|
|
|
/**
|
|
* Adds a listener to its requested list of packet receivers.
|
|
*
|
|
* @param listener - listener with a list of packets to receive notifications for.
|
|
* @param whitelist - the packet whitelist to use.
|
|
*/
|
|
public void addListener(T listener, ListeningWhitelist whitelist) {
|
|
final PrioritizedListener<T> prioritized = new PrioritizedListener<>(listener, whitelist.getPriority());
|
|
for (PacketType type : whitelist.getTypes()) {
|
|
this.addListener(type, prioritized);
|
|
}
|
|
}
|
|
|
|
// Add the listener to a specific packet notification list
|
|
private void addListener(PacketType type, PrioritizedListener<T> listener) {
|
|
SortedCopyOnWriteArray<PrioritizedListener<T>> list = this.mapListeners.get(type);
|
|
|
|
// We don't want to create this for every lookup
|
|
if (list == null) {
|
|
// It would be nice if we could use a PriorityBlockingQueue, but it doesn't preserve iterator order,
|
|
// which is an essential feature for our purposes.
|
|
final SortedCopyOnWriteArray<PrioritizedListener<T>> value = new SortedCopyOnWriteArray<>();
|
|
|
|
// We may end up creating multiple multisets, but we'll agree on which to use
|
|
list = this.mapListeners.putIfAbsent(type, value);
|
|
|
|
if (list == null) {
|
|
list = value;
|
|
}
|
|
}
|
|
|
|
// Thread safe
|
|
list.add(listener);
|
|
}
|
|
|
|
/**
|
|
* Removes the given listener from the packet event list.
|
|
*
|
|
* @param listener - listener to remove.
|
|
* @param whitelist - the packet whitelist that was used.
|
|
* @return Every packet ID that was removed due to no listeners.
|
|
*/
|
|
public List<PacketType> removeListener(T listener, ListeningWhitelist whitelist) {
|
|
List<PacketType> removedPackets = new ArrayList<>();
|
|
|
|
// Again, not terribly efficient. But adding or removing listeners should be a rare event.
|
|
for (PacketType type : whitelist.getTypes()) {
|
|
SortedCopyOnWriteArray<PrioritizedListener<T>> list = this.mapListeners.get(type);
|
|
|
|
if(list == null || list.isEmpty()) continue;
|
|
|
|
// Remove any listeners
|
|
// Remove this listener. Note that priority is generally ignored.
|
|
list.remove(new PrioritizedListener<T>(listener, whitelist.getPriority()));
|
|
|
|
if (list.isEmpty()) {
|
|
this.mapListeners.remove(type);
|
|
removedPackets.add(type);
|
|
}
|
|
// Move on to the next
|
|
}
|
|
return removedPackets;
|
|
}
|
|
|
|
/**
|
|
* Retrieve the registered listeners, in order from the lowest to the highest priority.
|
|
* <p>
|
|
* The returned list is thread-safe and doesn't require synchronization.
|
|
*
|
|
* @param type - packet type.
|
|
* @return Registered listeners.
|
|
*/
|
|
public Collection<PrioritizedListener<T>> getListener(PacketType type) {
|
|
return this.mapListeners.get(type);
|
|
}
|
|
|
|
/**
|
|
* Retrieve every listener.
|
|
*
|
|
* @return Every listener.
|
|
*/
|
|
public Iterable<PrioritizedListener<T>> values() {
|
|
return Iterables.concat(this.mapListeners.values());
|
|
}
|
|
|
|
/**
|
|
* Retrieve every registered packet type:
|
|
*
|
|
* @return Registered packet type.
|
|
*/
|
|
public Set<PacketType> keySet() {
|
|
return this.mapListeners.keySet();
|
|
}
|
|
|
|
/**
|
|
* Remove all packet listeners.
|
|
*/
|
|
protected void clearListeners() {
|
|
this.mapListeners.clear();
|
|
}
|
|
}
|