Improve packet class lookup performance by mainaining a inverse map.

ProtocolLib/src/main/java/com/comphenix/protocol/injector/packet/InverseMaps.java

@@ -0,0 +1,130 @@
+package com.comphenix.protocol.injector.packet;
+
+import java.lang.reflect.Field;
+import java.util.Map;
+
+import com.comphenix.protocol.reflect.FieldUtils;
+import com.google.common.base.Predicate;
+import com.google.common.collect.ForwardingMap;
+import com.google.common.collect.ForwardingMultimap;
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimap;
+
+public class InverseMaps {
+	private InverseMaps() {
+		// Not constructable
+	}
+	
+	public static <K, V> Multimap<K, V> inverseMultimap(final Map<V, K> map, final Predicate<Map.Entry<V, K>> filter) {
+		final MapContainer container = new MapContainer(map);
+		
+		return new ForwardingMultimap<K, V>() {
+			// The cached multimap
+			private Multimap<K, V> inverseMultimap;
+			
+			@Override
+			protected Multimap<K, V> delegate() {
+				if (container.hasChanged()) {
+					inverseMultimap = HashMultimap.create();
+					
+					// Construct the inverse map
+					for (Map.Entry<V, K> entry : map.entrySet()) {
+						if (filter.apply(entry)) {
+							inverseMultimap.put(entry.getValue(), entry.getKey());
+						}
+					}
+					container.setChanged(false);
+				}
+				return inverseMultimap;
+			}
+		};
+	}
+	
+	public static <K, V> Map<K, V> inverseMap(final Map<V, K> map, final Predicate<Map.Entry<V, K>> filter) {
+		final MapContainer container = new MapContainer(map);
+		
+		return new ForwardingMap<K, V>() {
+			// The cached map
+			private Map<K, V> inverseMap;
+			
+			@Override
+			protected Map<K, V> delegate() {
+				if (container.hasChanged()) {
+					inverseMap = Maps.newHashMap();
+					
+					// Construct the inverse map
+					for (Map.Entry<V, K> entry : map.entrySet()) {
+						if (filter.apply(entry)) {
+							inverseMap.put(entry.getValue(), entry.getKey());
+						}
+					}
+					container.setChanged(false);
+				}
+				return inverseMap;
+			}
+		};
+	}
+	
+	/**
+	 * Represents a class that can detect if a map has changed.
+	 * @author Kristian
+	 */
+	private static class MapContainer {
+		// For detecting changes
+		private Field modCountField;
+		private int lastModCount;
+		
+		// The object along with whether or not this is the initial run
+		private Object source;
+		private boolean changed;
+		
+		public MapContainer(Object source) {
+			this.source = source;
+			this.changed = true;
+			this.modCountField = FieldUtils.getField(source.getClass(), "modCount", true);
+		}
+		
+		/**
+		 * Determine if the map has changed.
+		 * @return TRUE if it has, FALSE otherwise.
+		 */
+		public boolean hasChanged() {
+			// Check if unchanged
+			checkChanged();
+			return changed;
+		}
+		
+		/**
+		 * Mark the map as changed or unchanged.
+		 * @param changed - TRUE if the map has changed, FALSE otherwise.
+		 */
+		public void setChanged(boolean changed) {
+			this.changed = changed;
+		}
+		
+		/**
+		 * Check for modifications to the current map.
+		 */
+		protected void checkChanged() {
+			if (!changed) {
+				if (getModificationCount() != lastModCount) {
+					lastModCount = getModificationCount();
+					changed = true;
+				}
+			}
+		}
+		
+		/**
+		 * Retrieve the current modification count.
+		 * @return The current count, or something different than lastModCount if not accessible.
+		 */
+		private int getModificationCount() {
+			try {
+				return modCountField != null ? modCountField.getInt(source) : lastModCount + 1;
+			} catch (Exception e) {
+				throw new RuntimeException("Unable to retrieve modCount.", e);
+			}
+		}
+	}
+}

ProtocolLib/src/main/java/com/comphenix/protocol/injector/packet/PacketRegistry.java

@@ -22,6 +22,9 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.Map.Entry;
+
+import javax.annotation.Nullable;
 
 import net.sf.cglib.proxy.Factory;
 
@@ -36,8 +39,10 @@ import com.comphenix.protocol.reflect.fuzzy.FuzzyFieldContract;
 import com.comphenix.protocol.reflect.fuzzy.FuzzyMethodContract;
 import com.comphenix.protocol.utility.MinecraftReflection;
 import com.comphenix.protocol.wrappers.TroveWrapper;
-import com.google.common.base.Objects;
+import com.google.common.base.Predicate;
 import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Multimap;
 
 /**
  * Static packet registry in Minecraft.
@@ -60,6 +65,10 @@ public class PacketRegistry {
 	// The packet class to packet ID translator
 	private static Map<Class, Integer> packetToID;
 	
+	// Packet IDs to classes, grouped by whether or not they're vanilla or custom defined
+	private static Multimap<Integer, Class> customIdToPacket;
+	private static Map<Integer, Class> vanillaIdToPacket;
+	
 	// Whether or not certain packets are sent by the client or the server
 	private static ImmutableSet<Integer> serverPackets;
 	private static ImmutableSet<Integer> clientPackets;
@@ -93,8 +102,23 @@ public class PacketRegistry {
 			} catch (IllegalAccessException e) {
 				throw new RuntimeException("Unable to retrieve the packetClassToIdMap", e);
 			}
-		}
 			
+			// Create the inverse maps
+			customIdToPacket = InverseMaps.inverseMultimap(packetToID, new Predicate<Map.Entry<Class, Integer>>() {
+				@Override
+				public boolean apply(@Nullable Entry<Class, Integer> entry) {
+					return !MinecraftReflection.isMinecraftClass(entry.getKey());
+				}
+			});
+			
+			// And the vanilla pack - here we assume a unique ID to class mapping
+			vanillaIdToPacket = InverseMaps.inverseMap(packetToID, new Predicate<Map.Entry<Class, Integer>>() {
+				@Override
+				public boolean apply(@Nullable Entry<Class, Integer> entry) {
+					return MinecraftReflection.isMinecraftClass(entry.getKey());
+				}
+			});
+		}
 		return packetToID;
 	}
 	
@@ -248,24 +272,30 @@ public class PacketRegistry {
 	 * @return The associated class.
 	 */
 	public static Class getPacketClassFromID(int packetID, boolean forceVanilla) {
-		
 		Map<Integer, Class> lookup = forceVanilla ? previousValues : overwrittenPackets;
+		Class<?> result = null;
 		
 		// Optimized lookup
 		if (lookup.containsKey(packetID)) {
 			return removeEnhancer(lookup.get(packetID), forceVanilla);
 		}
 		
-		// Will most likely not be used
-		for (Map.Entry<Class, Integer> entry : getPacketToID().entrySet()) {
-			if (Objects.equal(entry.getValue(), packetID)) {
-				// Attempt to get the vanilla class here too
-				if (!forceVanilla || MinecraftReflection.isMinecraftClass(entry.getKey()))
-					return removeEnhancer(entry.getKey(), forceVanilla);
-			}
+		// Refresh lookup tables
+		getPacketToID();
+
+		// See if we can look for non-vanilla classes
+		if (!forceVanilla) {
+			result = Iterables.getFirst(customIdToPacket.get(packetID), null);
+		}
+		if (result == null) {
+			result = vanillaIdToPacket.get(packetID);
 		}
 		
-		throw new IllegalArgumentException("The packet ID " + packetID + " is not registered.");
+		// See if we got it
+		if (result != null)
+			return result;
+		else
+			throw new IllegalArgumentException("The packet ID " + packetID + " is not registered.");
 	}
 	
 	/**