fix: fail gracefully for unknown protocol

Addresses #2998

.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

.github/CONTRIBUTING.md

@@ -19,7 +19,7 @@ This page will detail specific things that must be done if you intend to contrib
 
 #### Ready? Let's get started!
 1. Read the [Protocol Changes](http://wiki.vg/Protocol_History). Always make sure the list is both
-complete and correct. If you're unsure, don't hesitate to ask in #mcdevs (the people who maintain wiki.vg) on [freenode.net](http://freenode.net)
+complete and correct. If you're unsure, don't hesitate to ask in #mcdevs (the people who maintain wiki.vg) on [libera.chat](http://libera.chat)
 or #spigot on [irc.spi.gt](http://irc.spi.gt) ([webchat](https://irc.spi.gt/iris/?channels=spigot)).
 2. Search for usages of the now-defunct NMS package guard and change them.
 3. The class `com.comphenix.protocol.PacketType` contains a list of all the packets. If any packets were added or removed
@@ -35,4 +35,4 @@ and the release date.
 8. `com.comphenix.protocol.utility.MinecraftProtocolVersion` contains a map of all the protocol version integers.
 If the protocol version has been incremented, add a new line to the map.
 9. `mvn` in root directory again. If it builds successfully, test on the appropriate version of a Spigot server. If
-the build fails, debug!
+the build fails, debug!

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+github: [dmulloy2]
+custom: ["https://paypal.me/dmulloy2"]

.github/ISSUE_TEMPLATE.md

@@ -2,9 +2,11 @@ _Follow this template except for feature requests. Use pastebin when providing /
 
 Make sure you've done the following:
 - [ ] You're using the latest build for your server version
+- [ ] This isn't fixed in a recent development build
 - [ ] This isn't an issue caused by another plugin
 - [ ] You've checked for duplicate issues
+- [ ] You didn't use `/reload`
 
 Debug paste link:
 
-Description and relevant errors:
+Description and relevant errors:

.github/ISSUE_TEMPLATE/api-question.md

@@ -0,0 +1,29 @@
+---
+name: API question
+about: Questions related to using ProtocolLib in your plugins
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Make sure you're doing the following**
+- [ ] You're using the latest build for your server version
+- [ ] This isn't an issue caused by another plugin
+- [ ] You've checked for duplicate issues
+- [ ] You didn't use `/reload`
+
+**Describe the question**
+A clear and concise description of what your question is.
+
+**API method(s) used**
+List what API method(s) you're using
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Code**
+If applicable, add relevant code from your project
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,32 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+- [ ] This issue is not solved in a development build
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Version Info**
+Provide your ProtocolLib install info with `/protocol dump` through pastebin.
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,22 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+- [ ] This feature is not currently present in a development build
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/workflows/build.yml

@@ -0,0 +1,28 @@
+name: ProtocolLib full build lifecycle
+
+on:
+  - push
+  - pull_request
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Setup java
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'temurin'
+          java-version: '21'
+          cache: 'gradle'
+
+      - name: Run gradle build lifecycle
+        run: ./gradlew build shadowJar --no-daemon
+
+      - name: Upload plugin file
+        uses: actions/upload-artifact@v2
+        with:
+          name: ProtocolLib
+          path: build/libs/ProtocolLib.jar

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,41 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ "master" ]
+  schedule:
+    - cron: '28 9 * * 1'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Setup java
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'temurin'
+          java-version: '21'
+          cache: 'gradle'
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v2
+        with:
+          languages: 'java'
+
+      - name: Run gradle build lifecycle
+        run: ./gradlew build -x test --no-daemon
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v2

.gitignore

@@ -8,7 +8,7 @@
 .settings/
 bin/
 .idea/
-.iml
+*.iml
 .ipr
 .iws
 
@@ -175,4 +175,10 @@ pip-log.txt
 .DS_Store
 
 # Log4J files
-logs/
+logs/
+
+.gradle/
+build/
+logs/
+.java-version
+gradle.properties

.travis.yml

@@ -1,13 +0,0 @@
-language: java
-jdk:
-  - oraclejdk8
-  - oraclejdk7
-script: mvn clean test
-#before_install: cd ProtocolLib
-install: true
-notifications:
-  email:
-    recipients:
-      - "dmulloy2@live.com"
-    on_success: change
-    on_failure: always

Readme.md

@@ -1,32 +1,33 @@
-# ProtocolLib [![Travis Status](https://travis-ci.org/dmulloy2/ProtocolLib.svg?branch=master)](https://travis-ci.org/dmulloy2/ProtocolLib)
+# ProtocolLib
 
-Certain tasks are impossible to perform with the standard Bukkit API, and may require 
-working with and even modify Minecraft directly. A common technique is to modify incoming 
-and outgoing [packets](http://www.wiki.vg/Protocol), or inject custom packets into the
-stream. This is quite cumbersome to do, however, and most implementations will break 
+Certain tasks are impossible to perform with the standard Bukkit API, and may require
+working with and even modifying Minecraft directly. A common technique is to modify incoming
+and outgoing [packets](https://wiki.vg/Protocol), or inject custom packets into the
+stream. This is quite cumbersome to do, however, and most implementations will break
 as soon as a new version of Minecraft has been released, mostly due to obfuscation.
 
-Critically, different plugins that use this approach may _hook_ into the same classes, 
-with unpredictable outcomes. More than often this causes plugins to crash, but it may also 
+Critically, different plugins that use this approach may _hook_ into the same classes,
+with unpredictable outcomes. More than often this causes plugins to crash, but it may also
 lead to more subtle bugs.
 
-Currently maintained by dmulloy2 on behalf of [Spigot](http://www.spigotmc.org/).
-
 ### Resources
 
-* [Resource Page](http://www.spigotmc.org/resources/protocollib.1997/)
-* [Dev Builds](http://ci.dmulloy2.net/job/ProtocolLib)
-* [JavaDoc](http://ci.dmulloy2.net/job/ProtocolLib/javadoc)
+* [Resource Page](https://www.spigotmc.org/resources/protocollib.1997/)
+* [Dev Builds](https://ci.dmulloy2.net/job/ProtocolLib)
+* [JavaDoc](https://ci.dmulloy2.net/job/ProtocolLib/javadoc/index.html)
 
 ### Compilation
 
-ProtocolLib is built with Maven and requires Spigot and SpigotAPI, which can be found [here](http://www.spigotmc.org/wiki/buildtools/).
+ProtocolLib is built with [Gradle](https://gradle.org/). If you have it installed, just run
+`./gradlew build` in the root project folder. Other gradle targets you may be interested in 
+include `clean`, `test`, and `shadowJar`. `shadowJar` will create a jar with all dependencies
+(ByteBuddy) included.
 
 ### A new API
 
-__ProtocolLib__ attempts to solve this problem by providing a event API, much like Bukkit, 
-that allows plugins to monitor, modify, or cancel packets sent and received. But, more importantly, 
-the API also hides all the gritty, obfuscated classes with a simple index based read/write system. 
+__ProtocolLib__ attempts to solve this problem by providing an event API, much like Bukkit,
+that allows plugins to monitor, modify, or cancel packets sent and received. But, more importantly,
+the API also hides all the gritty, obfuscated classes with a simple index based read/write system.
 You no longer have to reference CraftBukkit!
 
 ### Using ProtocolLib
@@ -35,7 +36,7 @@ To use this library, first add ProtocolLib.jar to your Java build path. Then, ad
 as a dependency or soft dependency to your plugin.yml file like any other plugin:
 
 ````yml
-depend: [ProtocolLib]
+depend: [ ProtocolLib ]
 ````
 
 You can also add ProtocolLib as a Maven dependency:
@@ -44,20 +45,32 @@ You can also add ProtocolLib as a Maven dependency:
 <repositories>
   <repository>
     <id>dmulloy2-repo</id>
-    <url>http://repo.dmulloy2.net/content/groups/public/</url>
+    <url>https://repo.dmulloy2.net/repository/public/</url>
   </repository>
-  ...
 </repositories>
 
 <dependencies>
   <dependency>
     <groupId>com.comphenix.protocol</groupId>
     <artifactId>ProtocolLib</artifactId>
-    <version>3.6.5</version>
+    <version>5.1.0</version>
+    <scope>provided</scope>
   </dependency>
 </dependencies>
 ````
 
+Or use the maven dependency with gradle:
+
+```gradle
+repositories {
+    maven { url "https://repo.dmulloy2.net/repository/public/" }
+}
+
+dependencies {
+    compileOnly 'com.comphenix.protocol:ProtocolLib:5.1.0'
+}
+```
+
 Then get a reference to ProtocolManager in onLoad() or onEnable() and you're good to go.
 
 ````java
@@ -72,16 +85,14 @@ To listen for packets sent by the server to a client, add a server-side listener
 
 ````java
 // Disable all sound effects
-protocolManager.addPacketListener(
-  new PacketAdapter(this, ListenerPriority.NORMAL, 
-          PacketType.Play.Server.NAMED_SOUND_EFFECT) {
+protocolManager.addPacketListener(new PacketAdapter(
+    this,
+    ListenerPriority.NORMAL,
+    PacketType.Play.Server.NAMED_SOUND_EFFECT
+) {
     @Override
     public void onPacketSending(PacketEvent event) {
-        // Item packets (id: 0x29)
-        if (event.getPacketType() == 
-                PacketType.Play.Server.NAMED_SOUND_EFFECT) {
-            event.setCancelled(true);
-        }
+        event.setCancelled(true);
     }
 });
 ````
@@ -91,20 +102,19 @@ censor by listening for Packet3Chat events:
 
 ````java
 // Censor
-protocolManager.addPacketListener(new PacketAdapter(this,
-        ListenerPriority.NORMAL, 
-        PacketType.Play.Client.CHAT) {
+protocolManager.addPacketListener(new PacketAdapter(
+    this,
+    ListenerPriority.NORMAL,
+    PacketType.Play.Client.CHAT
+) {
     @Override
     public void onPacketReceiving(PacketEvent event) {
-        if (event.getPacketType() == PacketType.Play.Client.CHAT) {
-            PacketContainer packet = event.getPacket();
-            String message = packet.getStrings().read(0);
+        PacketContainer packet = event.getPacket();
+        String message = packet.getStrings().read(0);
 
-            if (message.contains("shit")
-                    || message.contains("damn")) {
-                event.setCancelled(true);
-                event.getPlayer().sendMessage("Bad manners!");
-            }
+        if (message.contains("shit") || message.contains("damn")) {
+            event.setCancelled(true);
+            event.getPlayer().sendMessage("Bad manners!");
         }
     }
 });
@@ -115,49 +125,43 @@ protocolManager.addPacketListener(new PacketAdapter(this,
 Normally, you might have to do something ugly like the following:
 
 ````java
-Packet60Explosion fakeExplosion = new Packet60Explosion();
-	
-fakeExplosion.a = player.getLocation().getX();
-fakeExplosion.b = player.getLocation().getY();
-fakeExplosion.c = player.getLocation().getZ();
-fakeExplosion.d = 3.0F;
-fakeExplosion.e = new ArrayList<Object>();
+PacketPlayOutExplosion fakeExplosion = new PacketPlayOutExplosion(
+    player.getLocation().getX(),
+    player.getLocation().getY(),
+    player.getLocation().getZ(),
+    3.0F,
+    new ArrayList<>(),
+    new Vec3D(
+        player.getVelocity().getX() + 1,
+        player.getVelocity().getY() + 1,
+        player.getVelocity().getZ() + 1
+    )
+);
 
-((CraftPlayer) player).getHandle().netServerHandler.sendPacket(fakeExplosion);
+((CraftPlayer) player).getHandle().b.a(fakeExplosion);
 ````
 
-But with ProtocolLib, you can turn that into something more manageable. Notice that 
-you don't have to create an ArrayList with this version:
+But with ProtocolLib, you can turn that into something more manageable:
 
 ````java
-
 PacketContainer fakeExplosion = new PacketContainer(PacketType.Play.Server.EXPLOSION);
-fakeExplosion.getDoubles().
-    write(0, player.getLocation().getX()).
-    write(1, player.getLocation().getY()).
-    write(2, player.getLocation().getZ());
+fakeExplosion.getDoubles()
+    .write(0, player.getLocation().getX())
+    .write(1, player.getLocation().getY())
+    .write(2, player.getLocation().getZ());
 fakeExplosion.getFloat().write(0, 3.0F);
+fakeExplosion.getBlockPositionCollectionModifier().write(0, new ArrayList<>());
+fakeExplosion.getVectors().write(0, player.getVelocity().add(new Vector(1, 1, 1)));
 
-try {
-    protocolManager.sendServerPacket(player, fakeExplosion);
-} catch (InvocationTargetException e) {
-    throw new RuntimeException(
-        "Cannot send packet " + fakeExplosion, e);
-}
+protocolManager.sendServerPacket(player, fakeExplosion);
 ````
 
 ### Compatibility
 
 One of the main goals of this project was to achieve maximum compatibility with CraftBukkit. And the end
-result is quite flexible. Aside from netty package changes, it should be resilient against future changes.
-It's likely that I won't have to update ProtocolLib for anything but bug fixes and new features.
+result is quite flexible. It's likely that I won't have to update ProtocolLib for anything but bug fixes
+and new features.
 
-How is this possible? It all comes down to reflection in the end. Essentially, no name is hard coded - 
+How is this possible? It all comes down to reflection in the end. Essentially, no name is hard coded -
 every field, method and class is deduced by looking at field types, package names or parameter
 types. It's remarkably consistent across different versions.
-
-
-### Incompatibility
-
-The following plugins (to be expanded) are not compatible with ProtocolLib:
-* TagAPI

TinyProtocol/pom.xml

@@ -14,8 +14,8 @@
   <parent>
     <groupId>com.comphenix.protocol</groupId>
     <artifactId>ProtocolLib-Parent</artifactId>
-    <version>v3-SNAPSHOT</version>
-    <relativePath>../</relativePath>
+    <version>v4-SNAPSHOT</version>
+    <relativePath>../../</relativePath>
   </parent>
 
   <repositories>
@@ -25,7 +25,7 @@
     </repository>
     <repository>
       <id>dmulloy2-repo</id>
-      <url>http://repo.dmulloy2.net/content/groups/public/</url>
+      <url>https://repo.dmulloy2.net/repository/public/</url>
     </repository>
   </repositories>
 
@@ -42,8 +42,8 @@
         <artifactId>maven-compiler-plugin</artifactId>
         <version>3.0</version>
         <configuration>
-          <source>1.7</source>
-          <target>1.7</target>
+          <source>1.8</source>
+          <target>1.8</target>
         </configuration>
       </plugin>
 
@@ -77,20 +77,6 @@
     </plugins>
   </build>
 
-  <dependencies>
-    <dependency>
-      <groupId>org.spigotmc</groupId>
-      <artifactId>spigot-api</artifactId>
-      <version>1.8.8-R0.1-SNAPSHOT</version>
-    </dependency>
-    <dependency>
-      <groupId>org.spigotmc</groupId>
-      <artifactId>spigot</artifactId>
-      <version>1.8.8-R0.1-SNAPSHOT</version>
-      <scope>provided</scope>
-    </dependency>
-  </dependencies>
-
   <profiles>
     <profile>
       <id>release-sign-artifacts</id>

TinyProtocol/src/main/java/com/comphenix/tinyprotocol/ExamplePlugin.java

@@ -0,0 +1,117 @@
+package com.comphenix.tinyprotocol;
+
+import io.netty.channel.Channel;
+
+import org.bukkit.ChatColor;
+import org.bukkit.Location;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import com.comphenix.tinyprotocol.Reflection.ConstructorInvoker;
+import com.comphenix.tinyprotocol.Reflection.FieldAccessor;
+
+/**
+ * Represents an example plugin utilizing TinyProtocol
+ */
+public class ExamplePlugin extends JavaPlugin {
+    // Chat packets
+    private FieldAccessor<String> CHAT_MESSAGE = Reflection.getField("{nms}.PacketPlayInChat", String.class, 0);
+
+    // Explosion packet
+    private Class<?> particleClass = Reflection.getClass("{nms}.PacketPlayOutWorldParticles");
+    private FieldAccessor<String> particleName = Reflection.getField(particleClass, String.class, 0);
+    private FieldAccessor<Float> particleX = Reflection.getField(particleClass, float.class, 0);
+    private FieldAccessor<Float> particleY = Reflection.getField(particleClass, float.class, 1);
+    private FieldAccessor<Float> particleZ = Reflection.getField(particleClass, float.class, 2);
+    private FieldAccessor<Integer> particleCount = Reflection.getField(particleClass, int.class, 0);
+
+    // Server info packet
+    private Class<?> serverInfoClass = Reflection.getClass("{nms}.PacketStatusOutServerInfo");
+    private Class<Object> serverPingClass = Reflection.getUntypedClass("{nms}.ServerPing");
+    private Class<Object> playerSampleClass = Reflection.getUntypedClass("{nms}.ServerPingPlayerSample");
+    private FieldAccessor<Object> serverPing = Reflection.getField(serverInfoClass, serverPingClass, 0);
+    private FieldAccessor<Object> playerSample = Reflection.getField(serverPingClass, playerSampleClass, 0);
+    private ConstructorInvoker playerSampleInvoker = Reflection.getConstructor(playerSampleClass, int.class, int.class);
+
+    private TinyProtocol protocol;
+
+    @Override
+    public void onEnable() {
+        protocol = new TinyProtocol(this) {
+
+            @Override
+            public Object onPacketInAsync(Player sender, Channel channel, Object packet) {
+                // Cancel chat packets
+                if (CHAT_MESSAGE.hasField(packet)) {
+                    if (CHAT_MESSAGE.get(packet).contains("dirty")) {
+                        sendExplosion(sender);
+                        return null;
+                    }
+                }
+
+                if (particleName.hasField(packet)) {
+                    System.out.println("Sending particle field:" + packet);
+                }
+
+                return super.onPacketInAsync(sender, channel, packet);
+            }
+
+            @Override
+            public Object onPacketOutAsync(Player reciever, Channel channel, Object packet) {
+                if (serverInfoClass.isInstance(packet)) {
+                    Object ping = serverPing.get(packet);
+                    playerSample.set(ping, playerSampleInvoker.invoke(1000, 0));
+
+                    // Which is equivalent to:
+                    // serverPing.get(packet).setPlayerSample(new ServerPingPlayerSample(1000, 0));
+                    return packet;
+                }
+
+                return super.onPacketOutAsync(reciever, channel, packet);
+            }
+
+        };
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (sender instanceof Player) {
+            Player player = (Player) sender;
+
+            // Toggle injection
+            if (protocol.hasInjected(player)) {
+                protocol.uninjectPlayer(player);
+                sender.sendMessage(ChatColor.YELLOW + "Player " + player + " has been uninjected.");
+            } else {
+                protocol.injectPlayer(player);
+                sender.sendMessage(ChatColor.DARK_GREEN + "Player " + player + " has been injected.");
+            }
+
+            return true;
+        } else {
+            sender.sendMessage(ChatColor.RED + "Can only be invoked by a player.");
+        }
+
+        return false;
+    }
+
+    private void sendExplosion(Player player) {
+        try {
+            // Only visible for the client
+            Object explosionPacket = particleClass.newInstance();
+            Location loc = player.getLocation();
+            particleName.set(explosionPacket, "hugeexplosion");
+            particleX.set(explosionPacket, (float) loc.getX());
+            particleY.set(explosionPacket, (float) loc.getY());
+            particleZ.set(explosionPacket, (float) loc.getZ());
+            particleCount.set(explosionPacket, 1);
+
+            // Send the packet to the player
+            protocol.sendPacket(player, explosionPacket);
+        } catch (Exception e) {
+            throw new RuntimeException("Cannot send packet.", e);
+        }
+    }
+}

TinyProtocol/src/main/java/com/comphenix/tinyprotocol/Reflection.java

@@ -0,0 +1,502 @@
+package com.comphenix.tinyprotocol;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.Arrays;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.bukkit.Bukkit;
+
+/**
+ * An utility class that simplifies reflection in Bukkit plugins.
+ * 
+ * @author Kristian
+ */
+public final class Reflection {
+    /**
+     * An interface for invoking a specific constructor.
+     */
+    public interface ConstructorInvoker {
+        /**
+         * Invoke a constructor for a specific class.
+         * 
+         * @param arguments - the arguments to pass to the constructor.
+         * @return The constructed object.
+         */
+        public Object invoke(Object... arguments);
+    }
+
+    /**
+     * An interface for invoking a specific method.
+     */
+    public interface MethodInvoker {
+        /**
+         * Invoke a method on a specific target object.
+         * 
+         * @param target - the target object, or NULL for a static method.
+         * @param arguments - the arguments to pass to the method.
+         * @return The return value, or NULL if is void.
+         */
+        public Object invoke(Object target, Object... arguments);
+    }
+
+    /**
+     * An interface for retrieving the field content.
+     * 
+     * @param <T> - field type.
+     */
+    public interface FieldAccessor<T> {
+        /**
+         * Retrieve the content of a field.
+         * 
+         * @param target - the target object, or NULL for a static field.
+         * @return The value of the field.
+         */
+        public T get(Object target);
+
+        /**
+         * Set the content of a field.
+         * 
+         * @param target - the target object, or NULL for a static field.
+         * @param value - the new value of the field.
+         */
+        public void set(Object target, Object value);
+
+        /**
+         * Determine if the given object has this field.
+         * 
+         * @param target - the object to test.
+         * @return TRUE if it does, FALSE otherwise.
+         */
+        public boolean hasField(Object target);
+    }
+
+    // Deduce the net.minecraft.server.v* package
+    private static String OBC_PREFIX = Bukkit.getServer().getClass().getPackage().getName();
+    private static String NMS_PREFIX = OBC_PREFIX.replace("org.bukkit.craftbukkit", "net.minecraft.server");
+    private static String VERSION = OBC_PREFIX.replace("org.bukkit.craftbukkit", "").replace(".", "");
+
+    // Variable replacement
+    private static Pattern MATCH_VARIABLE = Pattern.compile("\\{([^\\}]+)\\}");
+
+    private Reflection() {
+        // Seal class
+    }
+
+    /**
+     * Retrieve a field accessor for a specific field type and name.
+     * 
+     * @param target - the target type.
+     * @param name - the name of the field, or NULL to ignore.
+     * @param fieldType - a compatible field type.
+     * @return The field accessor.
+     */
+    public static <T> FieldAccessor<T> getField(Class<?> target, String name, Class<T> fieldType) {
+        return getField(target, name, fieldType, 0);
+    }
+
+    /**
+     * Retrieve a field accessor for a specific field type and name.
+     * 
+     * @param className - lookup name of the class, see {@link #getClass(String)}.
+     * @param name - the name of the field, or NULL to ignore.
+     * @param fieldType - a compatible field type.
+     * @return The field accessor.
+     */
+    public static <T> FieldAccessor<T> getField(String className, String name, Class<T> fieldType) {
+        return getField(getClass(className), name, fieldType, 0);
+    }
+
+    /**
+     * Retrieve a field accessor for a specific field type and name.
+     * 
+     * @param target - the target type.
+     * @param fieldType - a compatible field type.
+     * @param index - the number of compatible fields to skip.
+     * @return The field accessor.
+     */
+    public static <T> FieldAccessor<T> getField(Class<?> target, Class<T> fieldType, int index) {
+        return getField(target, null, fieldType, index);
+    }
+
+    /**
+     * Retrieve a field accessor for a specific field type and name.
+     * 
+     * @param className - lookup name of the class, see {@link #getClass(String)}.
+     * @param fieldType - a compatible field type.
+     * @param index - the number of compatible fields to skip.
+     * @return The field accessor.
+     */
+    public static <T> FieldAccessor<T> getField(String className, Class<T> fieldType, int index) {
+        return getField(getClass(className), fieldType, index);
+    }
+
+    // Common method
+    private static <T> FieldAccessor<T> getField(Class<?> target, String name, Class<T> fieldType, int index) {
+        for (final Field field : target.getDeclaredFields()) {
+            if ((name == null || field.getName().equals(name)) && fieldType.isAssignableFrom(field.getType()) && index-- <= 0) {
+                field.setAccessible(true);
+
+                // A function for retrieving a specific field value
+                return new FieldAccessor<T>() {
+
+                    @Override
+                    @SuppressWarnings("unchecked")
+                    public T get(Object target) {
+                        try {
+                            return (T) field.get(target);
+                        } catch (IllegalAccessException e) {
+                            throw new RuntimeException("Cannot access reflection.", e);
+                        }
+                    }
+
+                    @Override
+                    public void set(Object target, Object value) {
+                        try {
+                            field.set(target, value);
+                        } catch (IllegalAccessException e) {
+                            throw new RuntimeException("Cannot access reflection.", e);
+                        }
+                    }
+
+                    @Override
+                    public boolean hasField(Object target) {
+                        // target instanceof DeclaringClass
+                        return field.getDeclaringClass().isAssignableFrom(target.getClass());
+                    }
+                };
+            }
+        }
+
+        // Search in parent classes
+        if (target.getSuperclass() != null)
+            return getField(target.getSuperclass(), name, fieldType, index);
+
+        throw new IllegalArgumentException("Cannot find field with type " + fieldType);
+    }
+
+    /**
+     * Retrieves a field with a given type and parameters. This is most useful
+     * when dealing with Collections.
+     *
+     * @param target the target class.
+     * @param fieldType Type of the field
+     * @param params Variable length array of type parameters
+     * @return The field
+     *
+     * @throws IllegalArgumentException If the field cannot be found
+     */
+    public static Field getParameterizedField(Class<?> target, Class<?> fieldType, Class<?>... params) {
+        for (Field field : target.getDeclaredFields()) {
+            if (field.getType().equals(fieldType)) {
+                Type type = field.getGenericType();
+                if (type instanceof ParameterizedType) {
+                    if (Arrays.equals(((ParameterizedType) type).getActualTypeArguments(), params))
+                        return field;
+                }
+            }
+        }
+
+        throw new IllegalArgumentException("Unable to find a field with type " + fieldType + " and params " + Arrays.toString(params));
+    }
+
+    /**
+     * Search for the first publicly and privately defined method of the given name and parameter count.
+     * 
+     * @param className - lookup name of the class, see {@link #getClass(String)}.
+     * @param methodName - the method name, or NULL to skip.
+     * @param params - the expected parameters.
+     * @return An object that invokes this specific method.
+     * @throws IllegalStateException If we cannot find this method.
+     */
+    public static MethodInvoker getMethod(String className, String methodName, Class<?>... params) {
+        return getTypedMethod(getClass(className), methodName, null, params);
+    }
+
+    /**
+     * Search for the first publicly and privately defined method of the given name and parameter count.
+     * 
+     * @param clazz - a class to start with.
+     * @param methodName - the method name, or NULL to skip.
+     * @param params - the expected parameters.
+     * @return An object that invokes this specific method.
+     * @throws IllegalStateException If we cannot find this method.
+     */
+    public static MethodInvoker getMethod(Class<?> clazz, String methodName, Class<?>... params) {
+        return getTypedMethod(clazz, methodName, null, params);
+    }
+
+    /**
+     * Search for the first publicly and privately defined method of the given name and parameter count.
+     * 
+     * @param clazz - a class to start with.
+     * @param methodName - the method name, or NULL to skip.
+     * @param returnType - the expected return type, or NULL to ignore.
+     * @param params - the expected parameters.
+     * @return An object that invokes this specific method.
+     * @throws IllegalStateException If we cannot find this method.
+     */
+    public static MethodInvoker getTypedMethod(Class<?> clazz, String methodName, Class<?> returnType, Class<?>... params) {
+        for (final Method method : clazz.getDeclaredMethods()) {
+            if ((methodName == null || method.getName().equals(methodName))
+                    && (returnType == null || method.getReturnType().equals(returnType))
+                    && Arrays.equals(method.getParameterTypes(), params)) {
+                method.setAccessible(true);
+
+                return new MethodInvoker() {
+
+                    @Override
+                    public Object invoke(Object target, Object... arguments) {
+                        try {
+                            return method.invoke(target, arguments);
+                        } catch (Exception e) {
+                            throw new RuntimeException("Cannot invoke method " + method, e);
+                        }
+                    }
+
+                };
+            }
+        }
+
+        // Search in every superclass
+        if (clazz.getSuperclass() != null)
+            return getMethod(clazz.getSuperclass(), methodName, params);
+
+        throw new IllegalStateException(String.format("Unable to find method %s (%s).", methodName, Arrays.asList(params)));
+    }
+
+    /**
+     * Search for the first publically and privately defined constructor of the given name and parameter count.
+     * 
+     * @param className - lookup name of the class, see {@link #getClass(String)}.
+     * @param params - the expected parameters.
+     * @return An object that invokes this constructor.
+     * @throws IllegalStateException If we cannot find this method.
+     */
+    public static ConstructorInvoker getConstructor(String className, Class<?>... params) {
+        return getConstructor(getClass(className), params);
+    }
+
+    /**
+     * Search for the first publically and privately defined constructor of the given name and parameter count.
+     * 
+     * @param clazz - a class to start with.
+     * @param params - the expected parameters.
+     * @return An object that invokes this constructor.
+     * @throws IllegalStateException If we cannot find this method.
+     */
+    public static ConstructorInvoker getConstructor(Class<?> clazz, Class<?>... params) {
+        for (final Constructor<?> constructor : clazz.getDeclaredConstructors()) {
+            if (Arrays.equals(constructor.getParameterTypes(), params)) {
+                constructor.setAccessible(true);
+
+                return new ConstructorInvoker() {
+
+                    @Override
+                    public Object invoke(Object... arguments) {
+                        try {
+                            return constructor.newInstance(arguments);
+                        } catch (Exception e) {
+                            throw new RuntimeException("Cannot invoke constructor " + constructor, e);
+                        }
+                    }
+
+                };
+            }
+        }
+
+        throw new IllegalStateException(String.format("Unable to find constructor for %s (%s).", clazz, Arrays.asList(params)));
+    }
+
+    /**
+     * Retrieve a class from its full name, without knowing its type on compile time.
+     * <p>
+     * This is useful when looking up fields by a NMS or OBC type.
+     * <p>
+     * 
+     * @see {@link #getClass()} for more information.
+     * @param lookupName - the class name with variables.
+     * @return The class.
+     */
+    public static Class<Object> getUntypedClass(String lookupName) {
+        @SuppressWarnings({ "rawtypes", "unchecked" })
+        Class<Object> clazz = (Class) getClass(lookupName);
+        return clazz;
+    }
+
+    /**
+     * Retrieve a class from its full name with alternatives, without knowing its type on compile time.
+     * <p>
+     * This is useful when looking up fields by a NMS or OBC type.
+     * <p>
+     * 
+     * @see {@link #getClass()} for more information.
+     * @param lookupName - the class name with variables.
+     * @param aliases - alternative names for this class.
+     * @return The class.
+     */
+    public static Class<Object> getUntypedClass(String lookupName, String... aliases) {
+        @SuppressWarnings({ "rawtypes", "unchecked" })
+        Class<Object> clazz = (Class) getClass(lookupName, aliases);
+        return clazz;
+    }
+
+    /**
+     * Retrieve a class from its full name.
+     * <p>
+     * Strings enclosed with curly brackets - such as {TEXT} - will be replaced according to the following table:
+     * <p>
+     * <table border="1">
+     * <tr>
+     * <th>Variable</th>
+     * <th>Content</th>
+     * </tr>
+     * <tr>
+     * <td>{nms}</td>
+     * <td>Actual package name of net.minecraft.server.VERSION</td>
+     * </tr>
+     * <tr>
+     * <td>{obc}</td>
+     * <td>Actual pacakge name of org.bukkit.craftbukkit.VERSION</td>
+     * </tr>
+     * <tr>
+     * <td>{version}</td>
+     * <td>The current Minecraft package VERSION, if any.</td>
+     * </tr>
+     * </table>
+     * 
+     * @param lookupName - the class name with variables.
+     * @return The looked up class.
+     * @throws IllegalArgumentException If a variable or class could not be found.
+     */
+    public static Class<?> getClass(String lookupName) {
+        return getCanonicalClass(expandVariables(lookupName));
+    }
+
+    /**
+     * Retrieve the first class that matches the full class name.
+     * <p>
+     * Strings enclosed with curly brackets - such as {TEXT} - will be replaced according to the following table:
+     * <p>
+     * <table border="1">
+     * <tr>
+     * <th>Variable</th>
+     * <th>Content</th>
+     * </tr>
+     * <tr>
+     * <td>{nms}</td>
+     * <td>Actual package name of net.minecraft.server.VERSION</td>
+     * </tr>
+     * <tr>
+     * <td>{obc}</td>
+     * <td>Actual pacakge name of org.bukkit.craftbukkit.VERSION</td>
+     * </tr>
+     * <tr>
+     * <td>{version}</td>
+     * <td>The current Minecraft package VERSION, if any.</td>
+     * </tr>
+     * </table>
+     * 
+     * @param lookupName - the class name with variables.
+     * @param aliases - alternative names for this class.
+     * @return Class object.
+     * @throws RuntimeException If we are unable to find any of the given classes.
+     */
+    public static Class<?> getClass(String lookupName, String... aliases) {
+        try {
+            // Try the main class first
+            return getClass(lookupName);
+        } catch (RuntimeException e) {
+            Class<?> success = null;
+
+            // Try every alias too
+            for (String alias : aliases) {
+                try {
+                    success = getClass(alias);
+                    break;
+                } catch (RuntimeException e1) {
+                    // e1.printStackTrace();
+                }
+            }
+
+            if (success != null) {
+                return success;
+            } else {
+                // Hack failed
+                throw new RuntimeException(String.format("Unable to find %s (%s)", lookupName, String.join(",", aliases)));
+            }
+        }
+    }
+
+    /**
+     * Retrieve a class in the net.minecraft.server.VERSION.* package.
+     * 
+     * @param name - the name of the class, excluding the package.
+     * @throws IllegalArgumentException If the class doesn't exist.
+     */
+    public static Class<?> getMinecraftClass(String name) {
+        return getCanonicalClass(NMS_PREFIX + "." + name);
+    }
+
+    /**
+     * Retrieve a class in the org.bukkit.craftbukkit.VERSION.* package.
+     * 
+     * @param name - the name of the class, excluding the package.
+     * @throws IllegalArgumentException If the class doesn't exist.
+     */
+    public static Class<?> getCraftBukkitClass(String name) {
+        return getCanonicalClass(OBC_PREFIX + "." + name);
+    }
+
+    /**
+     * Retrieve a class by its canonical name.
+     * 
+     * @param canonicalName - the canonical name.
+     * @return The class.
+     */
+    private static Class<?> getCanonicalClass(String canonicalName) {
+        try {
+            return Class.forName(canonicalName);
+        } catch (ClassNotFoundException e) {
+            throw new IllegalArgumentException("Cannot find " + canonicalName, e);
+        }
+    }
+
+    /**
+     * Expand variables such as "{nms}" and "{obc}" to their corresponding packages.
+     * 
+     * @param name - the full name of the class.
+     * @return The expanded string.
+     */
+    private static String expandVariables(String name) {
+        StringBuffer output = new StringBuffer();
+        Matcher matcher = MATCH_VARIABLE.matcher(name);
+
+        while (matcher.find()) {
+            String variable = matcher.group(1);
+            String replacement = "";
+
+            // Expand all detected variables
+            if ("nms".equalsIgnoreCase(variable))
+                replacement = NMS_PREFIX;
+            else if ("obc".equalsIgnoreCase(variable))
+                replacement = OBC_PREFIX;
+            else if ("version".equalsIgnoreCase(variable))
+                replacement = VERSION;
+            else
+                throw new IllegalArgumentException("Unknown variable: " + variable);
+
+            // Assume the expanded variables are all packages, and append a dot
+            if (replacement.length() > 0 && matcher.end() < name.length() && name.charAt(matcher.end()) != '.')
+                replacement += ".";
+            matcher.appendReplacement(output, Matcher.quoteReplacement(replacement));
+        }
+
+        matcher.appendTail(output);
+        return output.toString();
+    }
+}

TinyProtocol/src/main/java/com/comphenix/tinyprotocol/TinyProtocol.java

@@ -0,0 +1,541 @@
+package com.comphenix.tinyprotocol;
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelDuplexHandler;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.ChannelPipeline;
+import io.netty.channel.ChannelPromise;
+
+import java.lang.reflect.Field;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Level;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerLoginEvent;
+import org.bukkit.event.server.PluginDisableEvent;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import com.comphenix.tinyprotocol.Reflection.FieldAccessor;
+import com.comphenix.tinyprotocol.Reflection.MethodInvoker;
+import com.google.common.collect.Lists;
+import com.google.common.collect.MapMaker;
+import com.mojang.authlib.GameProfile;
+
+/**
+ * Represents a very tiny alternative to ProtocolLib.
+ * <p>
+ * It now supports intercepting packets during login and status ping (such as OUT_SERVER_PING)!
+ * 
+ * @author Kristian
+ */
+public abstract class TinyProtocol {
+    private static final AtomicInteger ID = new AtomicInteger(0);
+
+    // Required Minecraft classes
+    private static final Class<?> entityPlayerClass = Reflection.getClass("{nms}.EntityPlayer", "net.minecraft.server.level.EntityPlayer");
+    private static final Class<?> playerConnectionClass = Reflection.getClass("{nms}.PlayerConnection", "net.minecraft.server.network.PlayerConnection");
+    private static final Class<?> networkManagerClass = Reflection.getClass("{nms}.NetworkManager", "net.minecraft.network.NetworkManager");
+
+    // Used in order to lookup a channel
+    private static final MethodInvoker getPlayerHandle = Reflection.getMethod("{obc}.entity.CraftPlayer", "getHandle");
+    private static final FieldAccessor<?> getConnection = Reflection.getField(entityPlayerClass, null, playerConnectionClass);
+    private static final FieldAccessor<?> getManager = Reflection.getField(playerConnectionClass, null, networkManagerClass);
+    private static final FieldAccessor<Channel> getChannel = Reflection.getField(networkManagerClass, Channel.class, 0);
+
+    // Looking up ServerConnection
+    private static final Class<Object> minecraftServerClass = Reflection.getUntypedClass("{nms}.MinecraftServer", "net.minecraft.server.MinecraftServer");
+    private static final Class<Object> serverConnectionClass = Reflection.getUntypedClass("{nms}.ServerConnection", "net.minecraft.server.network.ServerConnection");
+    private static final FieldAccessor<Object> getMinecraftServer = Reflection.getField("{obc}.CraftServer", minecraftServerClass, 0);
+    private static final FieldAccessor<Object> getServerConnection = Reflection.getField(minecraftServerClass, serverConnectionClass, 0);
+
+    // Packets we have to intercept
+    private static final Class<?> PACKET_LOGIN_IN_START = Reflection.getClass("{nms}.PacketLoginInStart", "net.minecraft.network.protocol.login.PacketLoginInStart");
+    private static final FieldAccessor<GameProfile> getGameProfile = Reflection.getField(PACKET_LOGIN_IN_START, GameProfile.class, 0);
+
+    // Speedup channel lookup
+    private Map<String, Channel> channelLookup = new MapMaker().weakValues().makeMap();
+    private Listener listener;
+
+    // Channels that have already been removed
+    private Set<Channel> uninjectedChannels = Collections.newSetFromMap(new MapMaker().weakKeys().<Channel, Boolean>makeMap());
+
+    // List of network markers
+    private List<Object> networkManagers;
+
+    // Injected channel handlers
+    private List<Channel> serverChannels = new ArrayList<>();
+    private ChannelInboundHandlerAdapter serverChannelHandler;
+    private ChannelInitializer<Channel> beginInitProtocol;
+    private ChannelInitializer<Channel> endInitProtocol;
+
+    // Current handler name
+    private String handlerName;
+
+    protected volatile boolean closed;
+    protected Plugin plugin;
+
+    /**
+     * Construct a new instance of TinyProtocol, and start intercepting packets for all connected clients and future clients.
+     * <p>
+     * You can construct multiple instances per plugin.
+     * 
+     * @param plugin - the plugin.
+     */
+    public TinyProtocol(final Plugin plugin) {
+        this.plugin = plugin;
+
+        // Compute handler name
+        this.handlerName = getHandlerName();
+
+        // Prepare existing players
+        registerBukkitEvents();
+
+        try {
+            registerChannelHandler();
+            registerPlayers(plugin);
+        } catch (IllegalArgumentException ex) {
+            // Damn you, late bind
+            plugin.getLogger().info("[TinyProtocol] Delaying server channel injection due to late bind.");
+
+            new BukkitRunnable() {
+                @Override
+                public void run() {
+                    registerChannelHandler();
+                    registerPlayers(plugin);
+                    plugin.getLogger().info("[TinyProtocol] Late bind injection successful.");
+                }
+            }.runTask(plugin);
+        }
+    }
+
+    private void createServerChannelHandler() {
+        // Handle connected channels
+        endInitProtocol = new ChannelInitializer<Channel>() {
+
+            @Override
+            protected void initChannel(Channel channel) throws Exception {
+                try {
+                    // This can take a while, so we need to stop the main thread from interfering
+                    synchronized (networkManagers) {
+                        // Stop injecting channels
+                        if (!closed) {
+                            channel.eventLoop().submit(() -> injectChannelInternal(channel));
+                        }
+                    }
+                } catch (Exception e) {
+                    plugin.getLogger().log(Level.SEVERE, "Cannot inject incomming channel " + channel, e);
+                }
+            }
+
+        };
+
+        // This is executed before Minecraft's channel handler
+        beginInitProtocol = new ChannelInitializer<Channel>() {
+
+            @Override
+            protected void initChannel(Channel channel) throws Exception {
+                channel.pipeline().addLast(endInitProtocol);
+            }
+
+        };
+
+        serverChannelHandler = new ChannelInboundHandlerAdapter() {
+    
+            @Override
+            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+                Channel channel = (Channel) msg;
+
+                // Prepare to initialize ths channel
+                channel.pipeline().addFirst(beginInitProtocol);
+                ctx.fireChannelRead(msg);
+            }
+
+        };
+    }
+
+    /**
+     * Register bukkit events.
+     */
+    private void registerBukkitEvents() {
+        listener = new Listener() {
+
+            @EventHandler(priority = EventPriority.LOWEST)
+            public final void onPlayerLogin(PlayerLoginEvent e) {
+                if (closed)
+                    return;
+
+                Channel channel = getChannel(e.getPlayer());
+
+                // Don't inject players that have been explicitly uninjected
+                if (!uninjectedChannels.contains(channel)) {
+                    injectPlayer(e.getPlayer());
+                }
+            }
+
+            @EventHandler
+            public final void onPluginDisable(PluginDisableEvent e) {
+                if (e.getPlugin().equals(plugin)) {
+                    close();
+                }
+            }
+
+        };
+
+        plugin.getServer().getPluginManager().registerEvents(listener, plugin);
+    }
+
+    @SuppressWarnings("unchecked")
+    private void registerChannelHandler() {
+        Object mcServer = getMinecraftServer.get(Bukkit.getServer());
+        Object serverConnection = getServerConnection.get(mcServer);
+        boolean looking = true;
+
+        try {
+            Field field = Reflection.getParameterizedField(serverConnectionClass, List.class, networkManagerClass);
+            field.setAccessible(true);
+
+            networkManagers = (List<Object>) field.get(serverConnection);
+        } catch (Exception ex) {
+            plugin.getLogger().info("Encountered an exception checking list fields" + ex);
+            MethodInvoker method = Reflection.getTypedMethod(serverConnectionClass, null, List.class, serverConnectionClass);
+
+            networkManagers = (List<Object>) method.invoke(null, serverConnection);
+        }
+
+        if (networkManagers == null) {
+            throw new IllegalArgumentException("Failed to obtain list of network managers");
+        }
+        // We need to synchronize against this list
+        createServerChannelHandler();
+
+        // Find the correct list, or implicitly throw an exception
+        for (int i = 0; looking; i++) {
+            List<Object> list = Reflection.getField(serverConnection.getClass(), List.class, i).get(serverConnection);
+
+            for (Object item : list) {
+                if (!ChannelFuture.class.isInstance(item))
+                    break;
+
+                // Channel future that contains the server connection
+                Channel serverChannel = ((ChannelFuture) item).channel();
+
+                serverChannels.add(serverChannel);
+                serverChannel.pipeline().addFirst(serverChannelHandler);
+                looking = false;
+            }
+        }
+    }
+
+    private void unregisterChannelHandler() {
+        if (serverChannelHandler == null)
+            return;
+
+        for (Channel serverChannel : serverChannels) {
+            final ChannelPipeline pipeline = serverChannel.pipeline();
+
+            // Remove channel handler
+            serverChannel.eventLoop().execute(new Runnable() {
+
+                @Override
+                public void run() {
+                    try {
+                        pipeline.remove(serverChannelHandler);
+                    } catch (NoSuchElementException e) {
+                        // That's fine
+                    }
+                }
+
+            });
+        }
+    }
+
+    private void registerPlayers(Plugin plugin) {
+        for (Player player : plugin.getServer().getOnlinePlayers()) {
+            injectPlayer(player);
+        }
+    }
+
+    /**
+     * Invoked when the server is starting to send a packet to a player.
+     * <p>
+     * Note that this is not executed on the main thread.
+     * 
+     * @param receiver - the receiving player, NULL for early login/status packets.
+     * @param channel - the channel that received the packet. Never NULL.
+     * @param packet - the packet being sent.
+     * @return The packet to send instead, or NULL to cancel the transmission.
+     */
+    public Object onPacketOutAsync(Player receiver, Channel channel, Object packet) {
+        return packet;
+    }
+
+    /**
+     * Invoked when the server has received a packet from a given player.
+     * <p>
+     * Use {@link Channel#remoteAddress()} to get the remote address of the client.
+     * 
+     * @param sender - the player that sent the packet, NULL for early login/status packets.
+     * @param channel - channel that received the packet. Never NULL.
+     * @param packet - the packet being received.
+     * @return The packet to recieve instead, or NULL to cancel.
+     */
+    public Object onPacketInAsync(Player sender, Channel channel, Object packet) {
+        return packet;
+    }
+
+    /**
+     * Send a packet to a particular player.
+     * <p>
+     * Note that {@link #onPacketOutAsync(Player, Channel, Object)} will be invoked with this packet.
+     * 
+     * @param player - the destination player.
+     * @param packet - the packet to send.
+     */
+    public void sendPacket(Player player, Object packet) {
+        sendPacket(getChannel(player), packet);
+    }
+
+    /**
+     * Send a packet to a particular client.
+     * <p>
+     * Note that {@link #onPacketOutAsync(Player, Channel, Object)} will be invoked with this packet.
+     * 
+     * @param channel - client identified by a channel.
+     * @param packet - the packet to send.
+     */
+    public void sendPacket(Channel channel, Object packet) {
+        channel.pipeline().writeAndFlush(packet);
+    }
+
+    /**
+     * Pretend that a given packet has been received from a player.
+     * <p>
+     * Note that {@link #onPacketInAsync(Player, Channel, Object)} will be invoked with this packet.
+     * 
+     * @param player - the player that sent the packet.
+     * @param packet - the packet that will be received by the server.
+     */
+    public void receivePacket(Player player, Object packet) {
+        receivePacket(getChannel(player), packet);
+    }
+
+    /**
+     * Pretend that a given packet has been received from a given client.
+     * <p>
+     * Note that {@link #onPacketInAsync(Player, Channel, Object)} will be invoked with this packet.
+     * 
+     * @param channel - client identified by a channel.
+     * @param packet - the packet that will be received by the server.
+     */
+    public void receivePacket(Channel channel, Object packet) {
+        channel.pipeline().context("encoder").fireChannelRead(packet);
+    }
+
+    /**
+     * Retrieve the name of the channel injector, default implementation is "tiny-" + plugin name + "-" + a unique ID.
+     * <p>
+     * Note that this method will only be invoked once. It is no longer necessary to override this to support multiple instances.
+     * 
+     * @return A unique channel handler name.
+     */
+    protected String getHandlerName() {
+        return "tiny-" + plugin.getName() + "-" + ID.incrementAndGet();
+    }
+
+    /**
+     * Add a custom channel handler to the given player's channel pipeline, allowing us to intercept sent and received packets.
+     * <p>
+     * This will automatically be called when a player has logged in.
+     * 
+     * @param player - the player to inject.
+     */
+    public void injectPlayer(Player player) {
+        injectChannelInternal(getChannel(player)).player = player;
+    }
+
+    /**
+     * Add a custom channel handler to the given channel.
+     * 
+     * @param channel - the channel to inject.
+     * @return The intercepted channel, or NULL if it has already been injected.
+     */
+    public void injectChannel(Channel channel) {
+        injectChannelInternal(channel);
+    }
+
+    /**
+     * Add a custom channel handler to the given channel.
+     * 
+     * @param channel - the channel to inject.
+     * @return The packet interceptor.
+     */
+    private PacketInterceptor injectChannelInternal(Channel channel) {
+        try {
+            PacketInterceptor interceptor = (PacketInterceptor) channel.pipeline().get(handlerName);
+
+            // Inject our packet interceptor
+            if (interceptor == null) {
+                interceptor = new PacketInterceptor();
+                channel.pipeline().addBefore("packet_handler", handlerName, interceptor);
+                uninjectedChannels.remove(channel);
+            }
+
+            return interceptor;
+        } catch (IllegalArgumentException e) {
+            // Try again
+            return (PacketInterceptor) channel.pipeline().get(handlerName);
+        }
+    }
+
+    /**
+     * Retrieve the Netty channel associated with a player. This is cached.
+     * 
+     * @param player - the player.
+     * @return The Netty channel.
+     */
+    public Channel getChannel(Player player) {
+        Channel channel = channelLookup.get(player.getName());
+
+        // Lookup channel again
+        if (channel == null) {
+            Object connection = getConnection.get(getPlayerHandle.invoke(player));
+            Object manager = getManager.get(connection);
+
+            channelLookup.put(player.getName(), channel = getChannel.get(manager));
+        }
+
+        return channel;
+    }
+
+    /**
+     * Uninject a specific player.
+     * 
+     * @param player - the injected player.
+     */
+    public void uninjectPlayer(Player player) {
+        uninjectChannel(getChannel(player));
+    }
+
+    /**
+     * Uninject a specific channel.
+     * <p>
+     * This will also disable the automatic channel injection that occurs when a player has properly logged in.
+     * 
+     * @param channel - the injected channel.
+     */
+    public void uninjectChannel(final Channel channel) {
+        // No need to guard against this if we're closing
+        if (!closed) {
+            uninjectedChannels.add(channel);
+        }
+
+        // See ChannelInjector in ProtocolLib, line 590
+        channel.eventLoop().execute(new Runnable() {
+
+            @Override
+            public void run() {
+                channel.pipeline().remove(handlerName);
+            }
+
+        });
+    }
+
+    /**
+     * Determine if the given player has been injected by TinyProtocol.
+     * 
+     * @param player - the player.
+     * @return TRUE if it is, FALSE otherwise.
+     */
+    public boolean hasInjected(Player player) {
+        return hasInjected(getChannel(player));
+    }
+
+    /**
+     * Determine if the given channel has been injected by TinyProtocol.
+     * 
+     * @param channel - the channel.
+     * @return TRUE if it is, FALSE otherwise.
+     */
+    public boolean hasInjected(Channel channel) {
+        return channel.pipeline().get(handlerName) != null;
+    }
+
+    /**
+     * Cease listening for packets. This is called automatically when your plugin is disabled.
+     */
+    public final void close() {
+        if (!closed) {
+            closed = true;
+
+            // Remove our handlers
+            for (Player player : plugin.getServer().getOnlinePlayers()) {
+                uninjectPlayer(player);
+            }
+
+            // Clean up Bukkit
+            HandlerList.unregisterAll(listener);
+            unregisterChannelHandler();
+        }
+    }
+
+    /**
+     * Channel handler that is inserted into the player's channel pipeline, allowing us to intercept sent and received packets.
+     * 
+     * @author Kristian
+     */
+    private final class PacketInterceptor extends ChannelDuplexHandler {
+        // Updated by the login event
+        public volatile Player player;
+
+        @Override
+        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+            // Intercept channel
+            final Channel channel = ctx.channel();
+            handleLoginStart(channel, msg);
+
+            try {
+                msg = onPacketInAsync(player, channel, msg);
+            } catch (Exception e) {
+                plugin.getLogger().log(Level.SEVERE, "Error in onPacketInAsync().", e);
+            }
+
+            if (msg != null) {
+                super.channelRead(ctx, msg);
+            }
+        }
+
+        @Override
+        public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
+            try {
+                msg = onPacketOutAsync(player, ctx.channel(), msg);
+            } catch (Exception e) {
+                plugin.getLogger().log(Level.SEVERE, "Error in onPacketOutAsync().", e);
+            }
+
+            if (msg != null) {
+                super.write(ctx, msg, promise);
+            }
+        }
+
+        private void handleLoginStart(Channel channel, Object packet) {
+            if (PACKET_LOGIN_IN_START.isInstance(packet)) {
+                GameProfile profile = getGameProfile.get(packet);
+                channelLookup.put(profile.getName(), channel);
+            }
+        }
+    }
+}

build.gradle

@@ -0,0 +1,130 @@
+plugins {
+    id 'java-library'
+    id 'maven-publish'
+    id 'com.github.johnrengelman.shadow' version '8.1.1'
+}
+
+group = 'com.comphenix.protocol'
+version = '5.3.0-SNAPSHOT'
+description = 'Provides access to the Minecraft protocol'
+
+def isSnapshot = version.endsWith('-SNAPSHOT')
+
+repositories {
+    mavenLocal() // can speed up build, but may fail in CI
+    mavenCentral()
+
+    maven {
+        url 'https://repo.dmulloy2.net/repository/public/'
+    }
+
+    maven {
+        url 'https://hub.spigotmc.org/nexus/content/groups/public/'
+    }
+
+    maven {
+        url 'https://libraries.minecraft.net/'
+        metadataSources {
+            mavenPom()
+            artifact()
+            ignoreGradleMetadataRedirection()
+        }
+    }
+}
+
+dependencies {
+    implementation 'net.bytebuddy:byte-buddy:1.14.14'
+    compileOnly 'org.spigotmc:spigot-api:1.20.6-R0.1-SNAPSHOT'
+    compileOnly 'org.spigotmc:spigot:1.21-R0.1-SNAPSHOT:remapped-mojang'
+    compileOnly 'io.netty:netty-all:4.0.23.Final'
+    compileOnly 'net.kyori:adventure-text-serializer-gson:4.14.0'
+    compileOnly 'com.googlecode.json-simple:json-simple:1.1.1'
+
+    testImplementation 'org.junit.jupiter:junit-jupiter-engine:5.10.0'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.0'
+    testRuntimeOnly 'org.junit.platform:junit-platform-launcher:1.10.0'
+    testImplementation 'org.mockito:mockito-core:5.6.0'
+    testImplementation 'io.netty:netty-common:4.1.97.Final'
+    testImplementation 'io.netty:netty-transport:4.1.97.Final'
+    testImplementation 'org.spigotmc:spigot:1.21-R0.1-SNAPSHOT:remapped-mojang'
+    testImplementation 'net.kyori:adventure-text-serializer-gson:4.14.0'
+    testImplementation 'net.kyori:adventure-text-serializer-plain:4.14.0'
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+
+    withJavadocJar()
+    withSourcesJar()
+}
+
+jar {
+    manifest {
+        attributes(
+                'paperweight-mappings-namespace': 'mojang'
+        )
+    }
+}
+
+shadowJar {
+    dependencies {
+        include(dependency('net.bytebuddy:byte-buddy:.*'))
+    }
+    relocate 'net.bytebuddy', 'com.comphenix.net.bytebuddy'
+    archiveFileName = 'ProtocolLib.jar'
+}
+
+test {
+    useJUnitPlatform()
+    testLogging {
+        exceptionFormat = 'full'
+    }
+}
+
+compileTestJava {
+    sourceCompatibility = JavaVersion.VERSION_21
+    targetCompatibility = JavaVersion.VERSION_21
+}
+
+processResources {
+    def includeBuild = isSnapshot && System.getenv('BUILD_NUMBER')
+    def fullVersion = includeBuild
+        ? version + '-' + System.getenv('BUILD_NUMBER')
+        : version
+
+    eachFile { expand(['version': fullVersion]) }
+}
+
+publishing {
+    publications {
+        mavenJava(MavenPublication) {
+            from components.java
+
+            afterEvaluate {
+                artifactId = 'ProtocolLib'
+            }
+        }
+    }
+
+    repositories {
+        maven {
+            url isSnapshot
+                ? 'https://repo.dmulloy2.net/repository/snapshots/'
+                : 'https://repo.dmulloy2.net/repository/releases/'
+
+            credentials {
+                username project.nexusUsername
+                password project.nexusPassword
+            }
+        }
+    }
+}
+
+tasks.withType(JavaCompile) {
+    options.encoding = 'UTF-8'
+}
+
+tasks.withType(Javadoc) {
+    options.encoding = 'UTF-8'
+}

gradle.properties

@@ -0,0 +1,2 @@
+nexusUsername=""
+nexusPassword=""

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

gradlew

@@ -0,0 +1,249 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,92 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

jitpack.yml

@@ -0,0 +1,5 @@
+before_install:
+  - source "$HOME/.sdkman/bin/sdkman-init.sh"
+  - sdk update
+  - sdk install java 17.0.4-tem
+  - sdk use java 17.0.4-tem

modules/API/pom.xml

@@ -1,252 +0,0 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-  <modelVersion>4.0.0</modelVersion>
-  <artifactId>ProtocolLib-API</artifactId>
-  <name>ProtocolLib-API</name>
-  <version>4.2.1</version>
-
-  <description>Provides read/write access to the Minecraft protocol.</description>
-  <url>http://www.spigotmc.org/resources/protocollib.1997/</url>
-  <packaging>jar</packaging>
-
-  <parent>
-    <groupId>com.comphenix.protocol</groupId>
-    <artifactId>ProtocolLib-Parent</artifactId>
-    <version>v4-SNAPSHOT</version>
-    <relativePath>../../</relativePath>
-  </parent>
-
-  <properties>
-    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    <project.build.number></project.build.number>
-    <project.fullVersion>${project.version}</project.fullVersion>
-  </properties>
-
-  <build>
-    <defaultGoal>clean install</defaultGoal>
-    <sourceDirectory>src/main/java</sourceDirectory>
-    <testSourceDirectory>src/test/java</testSourceDirectory>
-    <resources>
-      <resource>
-        <directory>src/main/resources</directory>
-        <filtering>true</filtering>
-        <excludes>
-          <exclude>**/*.java</exclude>
-        </excludes>
-      </resource>
-    </resources>
-
-    <plugins>
-      <plugin>
-        <artifactId>maven-compiler-plugin</artifactId>
-        <version>3.5.1</version>
-        <configuration>
-          <source>1.7</source>
-          <target>1.7</target>
-        </configuration>
-      </plugin>
-
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-jar-plugin</artifactId>
-        <version>2.6</version>
-        <configuration>
-          <archive>
-            <manifestEntries>
-              <Main-Class>com.comphenix.protocol.Application</Main-Class>
-              <Implementation-Title>ProtocolLib</Implementation-Title>
-              <Implementation-Version>${project.fullVersion}</Implementation-Version>
-              <Implementation-Vendor>dmulloy2</Implementation-Vendor>
-            </manifestEntries>
-          </archive>
-          <finalName>ProtocolLib</finalName>
-        </configuration>
-      </plugin>
-
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-surefire-plugin</artifactId>
-        <version>2.10</version>
-        <configuration>
-          <systemProperties>
-            <property>
-              <name>projectVersion</name>
-              <value>${project.version}</value>
-            </property>
-          </systemProperties>
-        </configuration>
-      </plugin>
-    </plugins>
-  </build>
-
-  <profiles>
-    <profile>
-      <id>jenkins</id>
-      <activation>
-        <property>
-          <name>env.BUILD_NUMBER</name>
-        </property>
-      </activation>
-      <properties>
-        <project.build.number>-b${env.BUILD_NUMBER}</project.build.number>
-        <project.fullVersion>${project.version}${project.build.number}</project.fullVersion>
-      </properties>
-    </profile>
-
-    <profile>
-      <id>release-sign-artifacts</id>
-      <activation>
-        <property>
-          <name>performRelease</name>
-          <value>true</value>
-        </property>
-      </activation>
-      <properties>
-        <project.fullVersion>${project.version}</project.fullVersion>
-      </properties>
-      <build>
-        <plugins>
-          <plugin>
-            <groupId>org.apache.maven.plugins</groupId>
-            <artifactId>maven-source-plugin</artifactId>
-            <version>3.0.0</version>
-            <executions>
-              <execution>
-                <id>attach-sources</id>
-                <goals>
-                  <goal>jar</goal>
-                </goals>
-              </execution>
-            </executions>
-          </plugin>
-
-          <plugin>
-            <groupId>org.apache.maven.plugins</groupId>
-            <artifactId>maven-javadoc-plugin</artifactId>
-            <version>2.10.3</version>
-            <executions>
-              <execution>
-                <id>attach-javadocs</id>
-                <goals>
-                  <goal>jar</goal>
-                </goals>
-              </execution>
-            </executions>
-          </plugin>
-
-          <!-- TODO: Look into signing releases
-          <plugin>
-            <groupId>org.apache.maven.plugins</groupId>
-            <artifactId>maven-gpg-plugin</artifactId>
-            <version>1.6</version>
-            <executions>
-              <execution>
-                <id>sign-artifacts</id>
-                <phase>verify</phase>
-                <goals>
-                  <goal>sign</goal>
-                </goals>
-              </execution>
-            </executions>
-          </plugin>
-          -->
-
-        </plugins>
-      </build>
-    </profile>
-  </profiles>
-
-  <scm>
-    <connection>scm:git:git://github.com/dmulloy2/ProtocolLib.git</connection>
-    <developerConnection>scm:git:git@github.com:dmulloy2/ProtocolLib.git</developerConnection>
-    <url>https://github.com/dmulloy2/ProtocolLib</url>
-  </scm>
-
-  <licenses>
-    <license>
-      <name>GNU GENERAL PUBLIC LICENSE - Version 2, June 1991</name>
-      <url>http://www.gnu.org/licenses/gpl-2.0.txt</url>
-      <distribution>repo</distribution>
-    </license>
-  </licenses>
-
-  <developers>
-    <developer>
-      <id>dmulloy2</id>
-      <name>Dan Mulloy</name>
-      <url>http://dmulloy2.net/</url>
-      <roles>
-        <role>developer</role>
-        <role>maintainer</role>
-      </roles>
-    </developer>
-    <developer>
-      <id>aadnk</id>
-      <name>Kristian S. Stangeland</name>
-      <email>kr_stang@hotmail.com</email>
-      <url>http://comphenix.net/</url>
-      <roles>
-        <role>former author</role>
-      </roles>
-      <timezone>1</timezone>
-    </developer>
-  </developers>
-
-  <dependencies>
-    <!-- Included with Minecraft
-    <dependency>
-	  <groupId>io.netty</groupId>
-	  <artifactId>netty-all</artifactId>
-	  <version>4.0.23.Final</version>
-    </dependency>
-    -->
-    <dependency>
-      <groupId>org.spigotmc</groupId>
-      <artifactId>spigot-api</artifactId>
-      <version>1.11.2-R0.1-SNAPSHOT</version>
-      <scope>provided</scope>
-    </dependency>
-    <dependency>
-      <groupId>org.spigotmc</groupId>
-      <artifactId>spigot</artifactId>
-      <version>1.11.2-R0.1-SNAPSHOT</version>
-      <scope>provided</scope>
-    </dependency>
-    <dependency>
-      <groupId>cglib</groupId>
-      <artifactId>cglib-nodep</artifactId>
-      <version>2.2.2</version>
-      <scope>compile</scope>
-    </dependency>
-    <dependency>
-      <groupId>com.comphenix.executors</groupId>
-      <artifactId>BukkitExecutors</artifactId>
-      <version>1.1-SNAPSHOT</version>
-      <scope>compile</scope>
-    </dependency>
-    <dependency>
-      <groupId>junit</groupId>
-      <artifactId>junit</artifactId>
-      <version>4.10</version>
-      <scope>test</scope>
-    </dependency>
-    <dependency>
-      <groupId>org.mockito</groupId>
-      <artifactId>mockito-all</artifactId>
-      <version>1.8.4</version>
-      <scope>test</scope>
-    </dependency>
-    <dependency>
-      <groupId>org.powermock</groupId>
-      <artifactId>powermock-module-junit4</artifactId>
-      <version>1.5</version>
-      <scope>test</scope>
-    </dependency>
-    <dependency>
-      <groupId>org.powermock</groupId>
-      <artifactId>powermock-api-mockito</artifactId>
-      <version>1.5</version>
-      <scope>test</scope>
-    </dependency>
-  </dependencies>
-</project>

modules/API/src/main/java/com/comphenix/protocol/AsynchronousManager.java

@@ -1,155 +0,0 @@
-/*
- *  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;
-
-import java.util.Set;
-
-import org.bukkit.plugin.Plugin;
-
-import com.comphenix.protocol.async.AsyncListenerHandler;
-import com.comphenix.protocol.async.AsyncMarker;
-import com.comphenix.protocol.error.ErrorReporter;
-import com.comphenix.protocol.events.PacketEvent;
-import com.comphenix.protocol.events.PacketListener;
-
-/**
- * Represents a asynchronous packet handler.
- * 
- * @author Kristian
- */
-public interface AsynchronousManager {
-	/**
-	 * Registers an asynchronous packet handler.
-	 * <p>
-	 * Use {@link AsyncMarker#incrementProcessingDelay()} to delay a packet until its ready to be transmitted.
-	 * <p>
-	 * To start listening asynchronously, pass the getListenerLoop() runnable to a different thread.
-	 * @param listener - the packet listener that will receive these asynchronous events.
-	 * @return An asynchronous handler.
-	 */
-	public abstract AsyncListenerHandler registerAsyncHandler(PacketListener listener);
-
-	/**
-	 * Unregisters and closes the given asynchronous handler.
-	 * @param handler - asynchronous handler.
-	 */
-	public abstract void unregisterAsyncHandler(AsyncListenerHandler handler);
-
-	/**
-	 * Unregisters and closes the first asynchronous handler associated with the given listener.
-	 * @param listener - asynchronous listener
-	 */
-	public abstract void unregisterAsyncHandler(PacketListener listener);
-	
-	/**
-	 * Unregisters every asynchronous handler associated with this plugin.
-	 * @param plugin - the original plugin.
-	 */
-	public void unregisterAsyncHandlers(Plugin plugin);
-	
-	/**
-	 * Retrieves a immutable set containing the ID of the sent server packets that will be
-	 * observed by the asynchronous listeners.
-	 * <p>
-	 * Deprecated: Use {@link #getSendingTypes()} instead.
-	 * @return Every filtered server packet.
-	 */
-	@Deprecated
-	public abstract Set<Integer> getSendingFilters();
-
-	/**
-	 * Retrieves a immutable set containing the types of the sent server packets that will be
-	 * observed by the asynchronous listeners.
-	 * @return Every filtered server packet.
-	 */
-	public abstract Set<PacketType> getSendingTypes();
-	
-	/**
-	 * Retrieves a immutable set containing the ID of the recieved client packets that will be
-	 * <p>
-	 * Deprecated: Use {@link #getReceivingTypes()} instead.
-	 * observed by the asynchronous listeners.
-	 * @return Every filtered client packet.
-	 */
-	@Deprecated
-	public abstract Set<Integer> getReceivingFilters();
-	
-	/**
-	 * Retrieves a immutable set containing the types of the received client packets that will be
-	 * observed by the asynchronous listeners.
-	 * @return Every filtered client packet.
-	 */
-	public abstract Set<PacketType> getReceivingTypes();
-
-	/**
-	 * Determine if a given synchronous packet has asynchronous listeners.
-	 * @param packet - packet to test.
-	 * @return TRUE if it does, FALSE otherwise.
-	 */
-	public abstract boolean hasAsynchronousListeners(PacketEvent packet);
-
-	/**
-	 * Retrieve the default packet stream.
-	 * @return Default packet stream.
-	 */
-	public abstract PacketStream getPacketStream();
-
-	/**
-	 * Retrieve the default error reporter.
-	 * @return Default reporter.
-	 */
-	public abstract ErrorReporter getErrorReporter();
-
-	/**
-	 * Remove listeners, close threads and transmit every delayed packet.
-	 */
-	public abstract void cleanupAll();
-
-	/**
-	 * Signal that a packet is ready to be transmitted.
-	 * <p>
-	 * This should only be called if {@link com.comphenix.protocol.async.AsyncMarker#incrementProcessingDelay() AsyncMarker.incrementProcessingDelay()}
-	 * has been called previously.
-	 * @param packet - packet to signal.
-	 */
-	public abstract void signalPacketTransmission(PacketEvent packet);
-
-	/**
-	 * Register a synchronous listener that handles packets when they time out.
-	 * @param listener - synchronous listener that will handle timed out packets.
-	 */
-	public abstract void registerTimeoutHandler(PacketListener listener);
-	
-	/**
-	 * Unregisters a given timeout listener.
-	 * @param listener - the timeout listener to unregister.
-	 */
-	public abstract void unregisterTimeoutHandler(PacketListener listener);
-
-	/**
-	 * Get a immutable set of every registered timeout handler.
-	 * @return Set of every registered timeout handler.
-	 */
-	public abstract Set<PacketListener> getTimeoutHandlers();
-
-	/**
-	 * Get an immutable set of every registered asynchronous packet listener.
-	 * @return Set of every asynchronous packet listener.
-	 */
-	public abstract Set<PacketListener> getAsyncHandlers();
-}

modules/API/src/main/java/com/comphenix/protocol/PacketStream.java

@@ -1,114 +0,0 @@
-/*
- *  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;
-
-import java.lang.reflect.InvocationTargetException;
-
-import org.bukkit.entity.Player;
-
-import com.comphenix.protocol.events.ListenerPriority;
-import com.comphenix.protocol.events.NetworkMarker;
-import com.comphenix.protocol.events.PacketContainer;
-import com.comphenix.protocol.injector.netty.WirePacket;
-
-/**
- * Represents a object capable of sending or receiving packets.
- * 
- * @author Kristian
- */
-public interface PacketStream {
-	/**
-	 * Send a packet to the given player.
-	 * @param receiver - the reciever.
-	 * @param packet - packet to send.
-	 * @throws InvocationTargetException - if an error occured when sending the packet.
-	 */
-	public void sendServerPacket(Player receiver, PacketContainer packet)
-			throws InvocationTargetException;
-
-	/**
-	 * Send a packet to the given player.
-	 * @param receiver - the reciever.
-	 * @param packet - packet to send.
-	 * @param filters - whether or not to invoke any packet filters below {@link ListenerPriority#MONITOR}.
-	 * @throws InvocationTargetException - if an error occured when sending the packet.
-	 */
-	public void sendServerPacket(Player receiver, PacketContainer packet, boolean filters)
-			throws InvocationTargetException;
-	
-	/**
-	 * Send a packet to the given player.
-	 * @param receiver - the receiver.
-	 * @param packet - packet to send.
-	 * @param marker - the network marker to use.
-	 * @param filters - whether or not to invoke any packet filters below {@link ListenerPriority#MONITOR}.
-	 * @throws InvocationTargetException - if an error occured when sending the packet.
-	 */
-	public void sendServerPacket(Player receiver, PacketContainer packet, NetworkMarker marker, boolean filters)
-			throws InvocationTargetException;
-
-	/**
-	 * Send a wire packet to the given player.
-	 * @param receiver - the receiver.
-	 * @param id - packet id.
-	 * @param bytes - packet bytes.
-	 * @throws InvocationTargetException if an error occured when sending the packet.
-	 */
-	public void sendWirePacket(Player receiver, int id, byte[] bytes) throws InvocationTargetException;
-
-	/**
-	 * Send a wire packet to the given player.
-	 * @param receiver - the receiver.
-	 * @param packet - packet to send.
-	 * @throws InvocationTargetException if an error occured when sending the packet.
-	 */
-	public void sendWirePacket(Player receiver, WirePacket packet) throws InvocationTargetException;
-
-	/**
-	 * Simulate recieving a certain packet from a given player.
-	 * @param sender - the sender.
-	 * @param packet - the packet that was sent.
-	 * @throws InvocationTargetException If the reflection machinery failed.
-	 * @throws IllegalAccessException If the underlying method caused an error.
-	 */
-	public void recieveClientPacket(Player sender, PacketContainer packet)
-			throws IllegalAccessException, InvocationTargetException;
-
-	/**
-	 * Simulate recieving a certain packet from a given player.
-	 * @param sender - the sender.
-	 * @param packet - the packet that was sent.
-	 * @param filters - whether or not to invoke any packet filters below {@link ListenerPriority#MONITOR}.
-	 * @throws InvocationTargetException If the reflection machinery failed.
-	 * @throws IllegalAccessException If the underlying method caused an error.
-	 */
-	public void recieveClientPacket(Player sender, PacketContainer packet, boolean filters)
-			throws IllegalAccessException, InvocationTargetException;
-	
-	/**
-	 * Simulate recieving a certain packet from a given player.
-	 * @param sender - the sender.
-	 * @param packet - the packet that was sent.
-	 * @param marker - the network marker to use.
-	 * @param filters - whether or not to invoke any packet filters below {@link ListenerPriority#MONITOR}.
-	 * @throws InvocationTargetException If the reflection machinery failed.
-	 * @throws IllegalAccessException If the underlying method caused an error.
-	 */
-	public void recieveClientPacket(Player sender, PacketContainer packet, NetworkMarker marker, boolean filters)
-			throws IllegalAccessException, InvocationTargetException;
-}

modules/API/src/main/java/com/comphenix/protocol/PacketTypeLookup.java

@@ -1,187 +0,0 @@
-package com.comphenix.protocol;
-
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-import com.comphenix.protocol.PacketType.Protocol;
-import com.comphenix.protocol.PacketType.Sender;
-import com.comphenix.protocol.collections.IntegerMap;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.Multimap;
-
-/**
- * Retrieve a packet type based on its version and ID, optionally with protocol and sender too.
- * @author Kristian
- */
-class PacketTypeLookup {
-	public static class ProtocolSenderLookup {
-		// Unroll lookup for performance reasons
-		public final IntegerMap<PacketType> HANDSHAKE_CLIENT = IntegerMap.newMap();
-		public final IntegerMap<PacketType> HANDSHAKE_SERVER = IntegerMap.newMap();
-		public final IntegerMap<PacketType> GAME_CLIENT = IntegerMap.newMap();
-		public final IntegerMap<PacketType> GAME_SERVER = IntegerMap.newMap();
-		public final IntegerMap<PacketType> STATUS_CLIENT = IntegerMap.newMap();
-		public final IntegerMap<PacketType> STATUS_SERVER = IntegerMap.newMap();
-		public final IntegerMap<PacketType> LOGIN_CLIENT = IntegerMap.newMap();
-		public final IntegerMap<PacketType> LOGIN_SERVER = IntegerMap.newMap();
-		
-		/**
-		 * Retrieve the correct integer map for a specific protocol and sender.
-		 * @param protocol - the protocol.
-		 * @param sender - the sender.
-		 * @return The integer map of packets.
-		 */
-		public IntegerMap<PacketType> getMap(Protocol protocol, Sender sender) {
-			switch (protocol) {
-				case HANDSHAKING: 
-					return sender == Sender.CLIENT ? HANDSHAKE_CLIENT : HANDSHAKE_SERVER;
-				case PLAY:
-					return sender == Sender.CLIENT ? GAME_CLIENT : GAME_SERVER;
-				case STATUS:
-					return sender == Sender.CLIENT ? STATUS_CLIENT : STATUS_SERVER;
-				case LOGIN:
-					return sender == Sender.CLIENT ? LOGIN_CLIENT : LOGIN_SERVER;
-				default:
-					throw new IllegalArgumentException("Unable to find protocol " + protocol);
-			}
-		}
-	}
-
-	public static class ClassLookup {
-		// Unroll lookup for performance reasons
-		public final Map<String, PacketType> HANDSHAKE_CLIENT = new ConcurrentHashMap<String, PacketType>();
-		public final Map<String, PacketType> HANDSHAKE_SERVER = new ConcurrentHashMap<String, PacketType>();
-		public final Map<String, PacketType> GAME_CLIENT = new ConcurrentHashMap<String, PacketType>();
-		public final Map<String, PacketType> GAME_SERVER = new ConcurrentHashMap<String, PacketType>();
-		public final Map<String, PacketType> STATUS_CLIENT = new ConcurrentHashMap<String, PacketType>();
-		public final Map<String, PacketType> STATUS_SERVER = new ConcurrentHashMap<String, PacketType>();
-		public final Map<String, PacketType> LOGIN_CLIENT = new ConcurrentHashMap<String, PacketType>();
-		public final Map<String, PacketType> LOGIN_SERVER = new ConcurrentHashMap<String, PacketType>();
-		
-		/**
-		 * Retrieve the correct integer map for a specific protocol and sender.
-		 * @param protocol - the protocol.
-		 * @param sender - the sender.
-		 * @return The integer map of packets.
-		 */
-		public Map<String, PacketType> getMap(Protocol protocol, Sender sender) {
-			switch (protocol) {
-				case HANDSHAKING: 
-					return sender == Sender.CLIENT ? HANDSHAKE_CLIENT : HANDSHAKE_SERVER;
-				case PLAY:
-					return sender == Sender.CLIENT ? GAME_CLIENT : GAME_SERVER;
-				case STATUS:
-					return sender == Sender.CLIENT ? STATUS_CLIENT : STATUS_SERVER;
-				case LOGIN:
-					return sender == Sender.CLIENT ? LOGIN_CLIENT : LOGIN_SERVER;
-				default:
-					throw new IllegalArgumentException("Unable to find protocol " + protocol);
-			}
-		}
-	}
-	
-	// Packet IDs from 1.6.4 and below
-	private final IntegerMap<PacketType> legacyLookup = new IntegerMap<PacketType>();
-	private final IntegerMap<PacketType> serverLookup = new IntegerMap<PacketType>();
-	private final IntegerMap<PacketType> clientLookup = new IntegerMap<PacketType>();
-	
-	// Packets for 1.7.2
-	private final ProtocolSenderLookup idLookup = new ProtocolSenderLookup();
-
-	// Packets for 1.8+
-	private final ClassLookup classLookup = new ClassLookup();
-
-	// Packets based on name
-	private final Multimap<String, PacketType> nameLookup = HashMultimap.create();
-
-	/**
-	 * Add a collection of packet types to the lookup.
-	 * @param types - the types to add.
-	 */
-	public PacketTypeLookup addPacketTypes(Iterable<? extends PacketType> types) {
-		Preconditions.checkNotNull(types, "types cannot be NULL");
-		
-		for (PacketType type : types) {
-			int legacy = type.getLegacyId();
-			
-			// Skip unknown legacy packets
-			if (legacy != PacketType.UNKNOWN_PACKET) {
-				if (type.isServer())
-					serverLookup.put(type.getLegacyId(), type);
-				if (type.isClient())
-					clientLookup.put(type.getLegacyId(), type);
-				legacyLookup.put(type.getLegacyId(), type);
-			}
-			// Skip unknown current packets
-			if (type.getCurrentId() != PacketType.UNKNOWN_PACKET) {
-				idLookup.getMap(type.getProtocol(), type.getSender()).put(type.getCurrentId(), type);
-				classLookup.getMap(type.getProtocol(), type.getSender()).put(type.getClassNames()[0], type);
-			}
-			nameLookup.put(type.name(), type);
-		}
-		return this;
-	}
-	
-	/**
-	 * Retrieve a packet type from a legacy (1.6.4 and below) packet ID.
-	 * @param packetId - the legacy packet ID.
-	 * @return The corresponding packet type, or NULL if not found.
-	 */
-	public PacketType getFromLegacy(int packetId) {
-		return legacyLookup.get(packetId);
-	}
-	
-	/**
-	 * Retrieve an unmodifiable view of all the packet types with this name.
-	 * @param name - the name.
-	 * @return The packet types, usually one.
-	 */
-	public Collection<PacketType> getFromName(String name) {
-		return Collections.unmodifiableCollection(nameLookup.get(name));
-	}
-	
-	/**
-	 * Retrieve a packet type from a legacy (1.6.4 and below) packet ID.
-	 * @param packetId - the legacy packet ID.
-	 * @param preference - which packet type to look for first.
-	 * @return The corresponding packet type, or NULL if not found.
-	 */
-	public PacketType getFromLegacy(int packetId, Sender preference) {	
-		if (preference == Sender.CLIENT)
-			return getFirst(packetId, clientLookup, serverLookup);
-		else
-			return getFirst(packetId, serverLookup, clientLookup);
-	}
-	
-	// Helper method for looking up in two sets
-	private <T> T getFirst(int packetId, IntegerMap<T> first, IntegerMap<T> second) {
-		if (first.containsKey(packetId))
-			return first.get(packetId);
-		else
-			return second.get(packetId);
-	}
-	
-	/**
-	 * Retrieve a packet type from a protocol, sender and packet ID.
-	 * @param protocol - the current protocol.
-	 * @param sender - the sender.
-	 * @param packetId - the packet ID.
-	 * @return The corresponding packet type, or NULL if not found.
-	 * @deprecated IDs are no longer reliable
-	 */
-	@Deprecated
-	public PacketType getFromCurrent(Protocol protocol, Sender sender, int packetId) {
-		return idLookup.getMap(protocol, sender).get(packetId);
-	}
-
-	public PacketType getFromCurrent(Protocol protocol, Sender sender, String name) {
-		return classLookup.getMap(protocol, sender).get(name);
-	}
-
-	public ClassLookup getClassLookup() {
-		return classLookup;
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/Packets.java

@@ -1,300 +0,0 @@
-/*
- *  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;
-
-import com.comphenix.protocol.reflect.IntEnum;
-
-/**
- * List of known packet IDs since 1.3.2.
- * <p>
- * Deprecated: Use {@link PacketType} instead.
- * @author Kristian
- */
-@Deprecated
-public final class Packets {
-	
-	/**
-	 * The highest possible packet ID. It's unlikely that this value will ever change.
-	 */
-	public static final int MAXIMUM_PACKET_ID = 255;
-	
-	/**
-	 * The maximum number of unique packet IDs. It's unlikely this will ever change.
-	 */
-	public static final int PACKET_COUNT = 256;
-	
-	/**
-	 * List of packets sent only by the server.
-	 * <p>
-	 * Deprecated: Use {@link PacketType} instead.
-	 * @author Kristian
-	 */
-	@Deprecated
-	public static final class Server extends IntEnum {
-		/**
-		 * The singleton instance. Can also be retrieved from the parent class.
-		 */
-		private static Server INSTANCE = new Server();
-		
-		public static final int KEEP_ALIVE = 0;
-		public static final int LOGIN = 1;
-		public static final int CHAT = 3;
-		public static final int UPDATE_TIME = 4;
-		public static final int ENTITY_EQUIPMENT = 5;
-		public static final int SPAWN_POSITION = 6;
-		public static final int UPDATE_HEALTH = 8;
-		public static final int RESPAWN = 9;
-		public static final int FLYING = 10;
-		public static final int PLAYER_POSITION = 11;
-		public static final int PLAYER_LOOK = 12;
-		public static final int PLAYER_LOOK_MOVE = 13;
-		/**
-		 * Made bi-directional in 1.4.6.
-		 */
-		public static final int BLOCK_ITEM_SWITCH = 16;
-		public static final int ENTITY_LOCATION_ACTION = 17;
-		public static final int ARM_ANIMATION = 18;
-		public static final int NAMED_ENTITY_SPAWN = 20;
-		/**
-		 * Removed in 1.4.6 and replaced with VEHICLE_SPAWN. 
-		 * @see <a href="http://www.wiki.vg/Protocol_History#2012-12-20">Protocol History - MinecraftCoalition</a>
-		 */
-		@Deprecated()
-		public static final int PICKUP_SPAWN = 21;
-		public static final int COLLECT = 22;
-		public static final int VEHICLE_SPAWN = 23;
-		public static final int MOB_SPAWN = 24;
-		public static final int ENTITY_PAINTING = 25;
-		public static final int ADD_EXP_ORB = 26;
-		public static final int ENTITY_VELOCITY = 28;
-		public static final int DESTROY_ENTITY = 29;
-		public static final int ENTITY = 30;
-		public static final int REL_ENTITY_MOVE = 31;
-		public static final int ENTITY_LOOK = 32;
-		public static final int REL_ENTITY_MOVE_LOOK = 33;
-		public static final int ENTITY_TELEPORT = 34;
-		public static final int ENTITY_HEAD_ROTATION = 35;
-		public static final int ENTITY_STATUS = 38;
-		public static final int ATTACH_ENTITY = 39;
-		
-		/**
-		 * Sent when an entities DataWatcher is updated.
-		 * <p>
-		 * Remember to clone the packet if you are modifying it.
-		 */
-		public static final int ENTITY_METADATA = 40;
-		public static final int MOB_EFFECT = 41;
-		public static final int REMOVE_MOB_EFFECT = 42;
-		public static final int SET_EXPERIENCE = 43;
-		public static final int UPDATE_ATTRIBUTES = 44;
-		public static final int MAP_CHUNK = 51;
-		public static final int MULTI_BLOCK_CHANGE = 52;
-		public static final int BLOCK_CHANGE = 53;
-		public static final int PLAY_NOTE_BLOCK = 54;
-		public static final int BLOCK_BREAK_ANIMATION = 55;
-		public static final int MAP_CHUNK_BULK = 56;
-		public static final int EXPLOSION = 60;
-		public static final int WORLD_EVENT = 61;
-		public static final int NAMED_SOUND_EFFECT = 62;
-		public static final int WORLD_PARTICLES = 63;
-		public static final int BED = 70;
-		public static final int WEATHER = 71;
-		public static final int OPEN_WINDOW = 100;
-		public static final int CLOSE_WINDOW = 101;
-		public static final int SET_SLOT = 103;
-		public static final int WINDOW_ITEMS = 104;
-		public static final int CRAFT_PROGRESS_BAR = 105;
-		public static final int TRANSACTION = 106;
-		public static final int SET_CREATIVE_SLOT = 107;
-		public static final int UPDATE_SIGN = 130;
-		public static final int ITEM_DATA = 131;
-		
-		/**
-		 * Sent the first time a tile entity (chest inventory, etc.) is withing range of the player, or has been updated.
-		 * <p>
-		 * Remember to clone the packet if you are modifying it.
-		 */
-		public static final int TILE_ENTITY_DATA = 132;
-		public static final int OPEN_TILE_ENTITY = 133;
-		public static final int STATISTIC = 200;
-		public static final int PLAYER_INFO = 201;
-		public static final int ABILITIES = 202;
-		public static final int TAB_COMPLETE = 203;
-		public static final int SCOREBOARD_OBJECTIVE = 206;
-		public static final int UPDATE_SCORE  = 207;
-		public static final int DISPLAY_SCOREBOARD = 208;
-		public static final int TEAMS = 209;
-		public static final int CUSTOM_PAYLOAD = 250;
-		public static final int KEY_RESPONSE = 252;
-		public static final int KEY_REQUEST = 253;
-		public static final int KICK_DISCONNECT = 255;
-		
-		/**
-		 * This packet was introduced in 1.7.2.
-		 */
-		public static final int PING_TIME = 230;
-		
-		/**
-		 * This packet was introduced in 1.7.2.
-		 */
-		public static final int LOGIN_SUCCESS = 232;
-		
-		/**
-		 * A registry that parses between names and packet IDs.
-		 * @return The current server registry.
-		 */
-		public static Server getRegistry() {
-			return INSTANCE;
-		}
-
-		// We only allow a single instance of this class
-	    private Server() {
-			super();
-		}
-	}
-	
-	/**
-	 * List of packets sent by the client.
-	 * <p>
-	 * Deprecated: Use {@link PacketType} instead.
-	 * @author Kristian
-	 */
-	@Deprecated
-	public static class Client extends IntEnum {
-		/**
-		 * The singleton instance. Can also be retrieved from the parent class.
-		 */
-		private static Client INSTANCE = new Client();
-		
-		public static final int KEEP_ALIVE = 0;
-		public static final int LOGIN = 1;
-		public static final int HANDSHAKE = 2;
-		public static final int CHAT = 3;
-		public static final int USE_ENTITY = 7;
-		
-		/**
-		 * Since 1.3.1, the client no longer sends a respawn packet. Moved to CLIENT_COMMAND.
-		 */
-		@Deprecated
-		public static final int RESPAWN = 9;
-		
-		public static final int FLYING = 10;
-		public static final int PLAYER_POSITION = 11;
-		public static final int PLAYER_LOOK = 12;
-		public static final int PLAYER_LOOK_MOVE = 13;
-		public static final int BLOCK_DIG = 14;
-		public static final int PLACE = 15;
-		public static final int BLOCK_ITEM_SWITCH = 16;
-		public static final int ARM_ANIMATION = 18;
-		public static final int ENTITY_ACTION = 19;
-		public static final int PLAYER_INPUT = 27;
-		public static final int CLOSE_WINDOW = 101;
-		public static final int WINDOW_CLICK = 102;
-		public static final int TRANSACTION = 106;
-		public static final int SET_CREATIVE_SLOT = 107;
-		public static final int BUTTON_CLICK = 108;
-		public static final int UPDATE_SIGN = 130;
-		public static final int ABILITIES = 202;
-		public static final int TAB_COMPLETE = 203;
-		public static final int LOCALE_AND_VIEW_DISTANCE = 204;
-		public static final int CLIENT_COMMAND = 205;
-		public static final int CUSTOM_PAYLOAD = 250;
-		public static final int KEY_RESPONSE = 252;
-		public static final int GET_INFO = 254;
-		public static final int KICK_DISCONNECT = 255;
-		
-		/**
-		 * This packet was introduced in 1.7.2.
-		 */
-		public static final int PING_TIME = 230;
-		
-		/**
-		 * This packet was introduced in 1.7.2.
-		 */
-		public static final int LOGIN_START = 231;
-		
-		/**
-		 * A registry that parses between names and packet IDs.
-		 * @return The current client registry.
-		 */
-		public static Client getRegistry() {
-			return INSTANCE;
-		}
-
-		// Like above
-		private Client() {
-			super();
-		}
-	}
-	
-	/**
-	 * A registry that parses between names and packet IDs.
-	 * <p>
-	 * Deprecated: Use {@link PacketType} instead.
-	 * @return The current client registry.
-	 */
-	@Deprecated
-	public static Server getServerRegistry() {
-		return Server.getRegistry();
-	}
-
-	/**
-	 * A registry that parses between names and packet IDs.
-	 * <p>
-	 * Deprecated: Use {@link PacketType} instead.
-	 * @return The current server registry.
-	 */
-	@Deprecated
-	public static Client getClientRegistry() {
-		return Client.INSTANCE;
-	}
-	
-	/**
-	 * Find a packet by name. Must be capitalized and use underscores.
-	 * <p>
-	 * Deprecated: Use {@link PacketType} instead.
-	 * @param name - name of packet to find.
-	 * @return The packet ID found.
-	 */
-	@Deprecated
-	public static int valueOf(String name) {
-		Integer serverAttempt = Server.INSTANCE.valueOf(name);
-		
-		if (serverAttempt != null)
-			return serverAttempt;
-		else
-			return Client.INSTANCE.valueOf(name);
-	}
-	
-	/**
-	 * Retrieves the name of a packet.
-	 * <p>
-	 * Deprecated: Use {@link PacketType} instead.
-	 * @param packetID - packet to retrieve name.
-	 * @return The name, or NULL if unable to find such a packet.
-	 */
-	@Deprecated
-	public static String getDeclaredName(int packetID) {
-		String serverAttempt = Server.INSTANCE.getDeclaredName(packetID);
-		
-		if (serverAttempt != null)
-			return serverAttempt;
-		else
-			return Client.INSTANCE.getDeclaredName(packetID);
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/ProtocolConfig.java

@@ -1,504 +0,0 @@
-/**
- *  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;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Locale;
-
-import org.bukkit.configuration.Configuration;
-import org.bukkit.configuration.ConfigurationSection;
-import org.bukkit.plugin.Plugin;
-
-import com.comphenix.protocol.injector.PlayerInjectHooks;
-import com.google.common.base.Charsets;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Lists;
-import com.google.common.io.Files;
-
-/**
- * Represents the configuration of ProtocolLib.
- * 
- * @author Kristian
- */
-public class ProtocolConfig {
-	private static final String LAST_UPDATE_FILE = "lastupdate";
-
-	private static final String SECTION_GLOBAL = "global";
-	private static final String SECTION_AUTOUPDATER = "auto updater";
-
-	private static final String METRICS_ENABLED = "metrics";
-
-	private static final String IGNORE_VERSION_CHECK = "ignore version check";
-	private static final String BACKGROUND_COMPILER_ENABLED = "background compiler";
-
-	private static final String DEBUG_MODE_ENABLED = "debug";
-	private static final String DETAILED_ERROR = "detailed error";
-	private static final String INJECTION_METHOD = "injection method";
-
-	private static final String SCRIPT_ENGINE_NAME = "script engine";
-	private static final String SUPPRESSED_REPORTS = "suppressed reports";
-
-	private static final String UPDATER_NOTIFY = "notify";
-	private static final String UPDATER_DOWNLAD = "download";
-	private static final String UPDATER_DELAY = "delay";
-
-	// Defaults
-	private static final long DEFAULT_UPDATER_DELAY = 43200;
-
-	private Plugin plugin;
-	private Configuration config;
-	private boolean loadingSections;
-
-	private ConfigurationSection global;
-	private ConfigurationSection updater;
-
-	// Last update time
-	private long lastUpdateTime;
-	private boolean configChanged;
-	private boolean valuesChanged;
-
-	// Modifications
-	private int modCount;
-
-	public ProtocolConfig(Plugin plugin) {
-		this.plugin = plugin;
-		reloadConfig();
-	}
-
-	/**
-	 * Reload configuration file.
-	 */
-	public void reloadConfig() {
-		// Reset
-		configChanged = false;
-		valuesChanged = false;
-		modCount++;
-
-		this.config = plugin.getConfig();
-		this.lastUpdateTime = loadLastUpdate();
-		loadSections(!loadingSections);
-	}
-
-	/**
-	 * Load the last update time stamp from the file system.
-	 * 
-	 * @return Last update time stamp.
-	 */
-	private long loadLastUpdate() {
-		File dataFile = getLastUpdateFile();
-
-		if (dataFile.exists()) {
-			try {
-				return Long.parseLong(Files.toString(dataFile, Charsets.UTF_8));
-			} catch (NumberFormatException e) {
-				plugin.getLogger().warning("Cannot parse " + dataFile + " as a number.");
-			} catch (IOException e) {
-				plugin.getLogger().warning("Cannot read " + dataFile);
-			}
-		}
-		// Default last update
-		return 0;
-	}
-
-	/**
-	 * Store the given time stamp.
-	 * 
-	 * @param value - time stamp to store.
-	 */
-	private void saveLastUpdate(long value) {
-		File dataFile = getLastUpdateFile();
-
-		// The data folder must exist
-		dataFile.getParentFile().mkdirs();
-
-		if (dataFile.exists())
-			dataFile.delete();
-
-		try {
-			Files.write(Long.toString(value), dataFile, Charsets.UTF_8);
-		} catch (IOException e) {
-			throw new RuntimeException("Cannot write " + dataFile, e);
-		}
-	}
-
-	/**
-	 * Retrieve the file that is used to store the update time stamp.
-	 * 
-	 * @return File storing the update time stamp.
-	 */
-	private File getLastUpdateFile() {
-		return new File(plugin.getDataFolder(), LAST_UPDATE_FILE);
-	}
-
-	/**
-	 * Load data sections.
-	 * 
-	 * @param copyDefaults - whether or not to copy configuration defaults.
-	 */
-	private void loadSections(boolean copyDefaults) {
-		if (config != null) {
-			global = config.getConfigurationSection(SECTION_GLOBAL);
-		}
-		if (global != null) {
-			updater = global.getConfigurationSection(SECTION_AUTOUPDATER);
-			if (updater.getValues(true).isEmpty()) {
-				plugin.getLogger().warning("Updater section is missing, regenerate your config!");
-			}
-		}
-
-		// Automatically copy defaults
-		if (copyDefaults && (!getFile().exists() || global == null || updater == null)) {
-			loadingSections = true;
-
-			if (config != null)
-				config.options().copyDefaults(true);
-			plugin.saveDefaultConfig();
-			plugin.reloadConfig();
-			loadingSections = false;
-
-			// Inform the user
-			plugin.getLogger().info("Created default configuration.");
-		}
-	}
-
-	/**
-	 * Set a particular configuration key value pair.
-	 * 
-	 * @param section - the configuration root.
-	 * @param path - the path to the key.
-	 * @param value - the value to set.
-	 */
-	private void setConfig(ConfigurationSection section, String path, Object value) {
-		configChanged = true;
-		section.set(path, value);
-	}
-
-	@SuppressWarnings("unchecked")
-	private <T> T getGlobalValue(String path, T def) {
-		try {
-			return (T) global.get(path, def);
-		} catch (Throwable ex) {
-			return def;
-		}
-	}
-
-	@SuppressWarnings("unchecked")
-	private <T> T getUpdaterValue(String path, T def) {
-		try {
-			return (T) updater.get(path, def);
-		} catch (Throwable ex) {
-			return def;
-		}
-	}
-
-	/**
-	 * Retrieve a reference to the configuration file.
-	 * 
-	 * @return Configuration file on disk.
-	 */
-	public File getFile() {
-		return new File(plugin.getDataFolder(), "config.yml");
-	}
-
-	/**
-	 * Determine if detailed error reporting is enabled. Default FALSE.
-	 * 
-	 * @return TRUE if it is enabled, FALSE otherwise.
-	 */
-	public boolean isDetailedErrorReporting() {
-		return getGlobalValue(DETAILED_ERROR, false);
-	}
-
-	/**
-	 * Set whether or not detailed error reporting is enabled.
-	 * 
-	 * @param value - TRUE if it is enabled, FALSE otherwise.
-	 */
-	public void setDetailedErrorReporting(boolean value) {
-		global.set(DETAILED_ERROR, value);
-	}
-
-	/**
-	 * Retrieve whether or not ProtocolLib should determine if a new version has been released.
-	 * 
-	 * @return TRUE if it should do this automatically, FALSE otherwise.
-	 */
-	public boolean isAutoNotify() {
-		return getUpdaterValue(UPDATER_NOTIFY, true);
-	}
-
-	/**
-	 * Set whether or not ProtocolLib should determine if a new version has been released.
-	 * 
-	 * @param value - TRUE to do this automatically, FALSE otherwise.
-	 */
-	public void setAutoNotify(boolean value) {
-		setConfig(updater, UPDATER_NOTIFY, value);
-		modCount++;
-	}
-
-	/**
-	 * Retrieve whether or not ProtocolLib should automatically download the new version.
-	 * 
-	 * @return TRUE if it should, FALSE otherwise.
-	 */
-	public boolean isAutoDownload() {
-		return updater != null && getUpdaterValue(UPDATER_DOWNLAD, false);
-	}
-
-	/**
-	 * Set whether or not ProtocolLib should automatically download the new version.
-	 * 
-	 * @param value - TRUE if it should. FALSE otherwise.
-	 */
-	public void setAutoDownload(boolean value) {
-		setConfig(updater, UPDATER_DOWNLAD, value);
-		modCount++;
-	}
-
-	/**
-	 * Determine whether or not debug mode is enabled.
-	 * <p>
-	 * This grants access to the filter command.
-	 * 
-	 * @return TRUE if it is, FALSE otherwise.
-	 */
-	public boolean isDebug() {
-		return getGlobalValue(DEBUG_MODE_ENABLED, false);
-	}
-
-	/**
-	 * Set whether or not debug mode is enabled.
-	 * 
-	 * @param value - TRUE if it is enabled, FALSE otherwise.
-	 */
-	public void setDebug(boolean value) {
-		setConfig(global, DEBUG_MODE_ENABLED, value);
-		modCount++;
-	}
-
-	/**
-	 * Retrieve an immutable list of every suppressed report type.
-	 * 
-	 * @return Every suppressed report type.
-	 */
-	public ImmutableList<String> getSuppressedReports() {
-		return ImmutableList.copyOf(getGlobalValue(SUPPRESSED_REPORTS, new ArrayList<String>()));
-	}
-
-	/**
-	 * Set the list of suppressed report types,
-	 * 
-	 * @param reports - suppressed report types.
-	 */
-	public void setSuppressedReports(List<String> reports) {
-		global.set(SUPPRESSED_REPORTS, Lists.newArrayList(reports));
-		modCount++;
-	}
-
-	/**
-	 * Retrieve the amount of time to wait until checking for a new update.
-	 * 
-	 * @return The amount of time to wait.
-	 */
-	public long getAutoDelay() {
-		// Note that the delay must be greater than 59 seconds
-		return Math.max(getUpdaterValue(UPDATER_DELAY, 0), DEFAULT_UPDATER_DELAY);
-	}
-
-	/**
-	 * Set the amount of time to wait until checking for a new update.
-	 * <p>
-	 * This time must be greater than 59 seconds.
-	 * 
-	 * @param delaySeconds - the amount of time to wait.
-	 */
-	public void setAutoDelay(long delaySeconds) {
-		// Silently fix the delay
-		if (delaySeconds < DEFAULT_UPDATER_DELAY)
-			delaySeconds = DEFAULT_UPDATER_DELAY;
-		setConfig(updater, UPDATER_DELAY, delaySeconds);
-		modCount++;
-	}
-
-	/**
-	 * The version of Minecraft to ignore the built-in safety feature.
-	 * 
-	 * @return The version to ignore ProtocolLib's satefy.
-	 */
-	public String getIgnoreVersionCheck() {
-		return getGlobalValue(IGNORE_VERSION_CHECK, "");
-	}
-
-	/**
-	 * Sets under which version of Minecraft the version safety feature will be ignored.
-	 * <p>
-	 * This is useful if a server operator has tested and verified that a version of ProtocolLib works, but doesn't want or can't upgrade to a newer version.
-	 * 
-	 * @param ignoreVersion - the version of Minecraft where the satefy will be disabled.
-	 */
-	public void setIgnoreVersionCheck(String ignoreVersion) {
-		setConfig(global, IGNORE_VERSION_CHECK, ignoreVersion);
-		modCount++;
-	}
-
-	/**
-	 * Retrieve whether or not metrics is enabled.
-	 * 
-	 * @return TRUE if metrics is enabled, FALSE otherwise.
-	 */
-	public boolean isMetricsEnabled() {
-		return getGlobalValue(METRICS_ENABLED, true);
-	}
-
-	/**
-	 * Set whether or not metrics is enabled.
-	 * <p>
-	 * This setting will take effect next time ProtocolLib is started.
-	 * 
-	 * @param enabled - whether or not metrics is enabled.
-	 */
-	public void setMetricsEnabled(boolean enabled) {
-		setConfig(global, METRICS_ENABLED, enabled);
-		modCount++;
-	}
-
-	/**
-	 * Retrieve whether or not the background compiler for structure modifiers is enabled or not.
-	 * 
-	 * @return TRUE if it is enabled, FALSE otherwise.
-	 */
-	public boolean isBackgroundCompilerEnabled() {
-		return getGlobalValue(BACKGROUND_COMPILER_ENABLED, true);
-	}
-
-	/**
-	 * Set whether or not the background compiler for structure modifiers is enabled or not.
-	 * <p>
-	 * This setting will take effect next time ProtocolLib is started.
-	 * 
-	 * @param enabled - TRUE if is enabled/running, FALSE otherwise.
-	 */
-	public void setBackgroundCompilerEnabled(boolean enabled) {
-		setConfig(global, BACKGROUND_COMPILER_ENABLED, enabled);
-		modCount++;
-	}
-
-	/**
-	 * Retrieve the last time we updated, in seconds since 1970.01.01 00:00.
-	 * 
-	 * @return Last update time.
-	 */
-	public long getAutoLastTime() {
-		return lastUpdateTime;
-	}
-
-	/**
-	 * Set the last time we updated, in seconds since 1970.01.01 00:00.
-	 * <p>
-	 * Note that this is not considered to modify the configuration, so the modification count will not be incremented.
-	 * 
-	 * @param lastTimeSeconds - new last update time.
-	 */
-	public void setAutoLastTime(long lastTimeSeconds) {
-		this.valuesChanged = true;
-		this.lastUpdateTime = lastTimeSeconds;
-	}
-
-	/**
-	 * Retrieve the unique name of the script engine to use for filtering.
-	 * 
-	 * @return Script engine to use.
-	 */
-	public String getScriptEngineName() {
-		return getGlobalValue(SCRIPT_ENGINE_NAME, "JavaScript");
-	}
-
-	/**
-	 * Set the unique name of the script engine to use for filtering.
-	 * <p>
-	 * This setting will take effect next time ProtocolLib is started.
-	 * 
-	 * @param name - name of the script engine to use.
-	 */
-	public void setScriptEngineName(String name) {
-		setConfig(global, SCRIPT_ENGINE_NAME, name);
-		modCount++;
-	}
-
-	/**
-	 * Retrieve the default injection method.
-	 * 
-	 * @return Default method.
-	 */
-	public PlayerInjectHooks getDefaultMethod() {
-		return PlayerInjectHooks.NETWORK_SERVER_OBJECT;
-	}
-
-	/**
-	 * Retrieve the injection method that has been set in the configuration, or use a default value.
-	 * 
-	 * @return Injection method to use.
-	 * @throws IllegalArgumentException If the configuration option is malformed.
-	 */
-	public PlayerInjectHooks getInjectionMethod() throws IllegalArgumentException {
-		String text = global.getString(INJECTION_METHOD);
-
-		// Default hook if nothing has been set
-		PlayerInjectHooks hook = getDefaultMethod();
-
-		if (text != null)
-			hook = PlayerInjectHooks.valueOf(text.toUpperCase(Locale.ENGLISH).replace(" ", "_"));
-		return hook;
-	}
-
-	/**
-	 * Set the starting injection method to use.
-	 * 
-	 * @return Injection method.
-	 */
-	public void setInjectionMethod(PlayerInjectHooks hook) {
-		setConfig(global, INJECTION_METHOD, hook.name());
-		modCount++;
-	}
-
-	/**
-	 * Retrieve the number of modifications made to this configuration.
-	 * 
-	 * @return The number of modifications.
-	 */
-	public int getModificationCount() {
-		return modCount;
-	}
-
-	/**
-	 * Save the current configuration file.
-	 */
-	public void saveAll() {
-		if (valuesChanged)
-			saveLastUpdate(lastUpdateTime);
-		if (configChanged)
-			plugin.saveConfig();
-
-		// And we're done
-		valuesChanged = false;
-		configChanged = false;
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/ProtocolLibrary.java

@@ -1,143 +0,0 @@
-/**
- *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
- *  Copyright (C) 2016 dmulloy2
- *
- *  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;
-
-import java.util.Arrays;
-import java.util.List;
-
-import org.apache.commons.lang.Validate;
-import org.bukkit.plugin.Plugin;
-
-import com.comphenix.protocol.error.BasicErrorReporter;
-import com.comphenix.protocol.error.ErrorReporter;
-import com.google.common.util.concurrent.ListeningScheduledExecutorService;
-
-/**
- * The main entry point for ProtocolLib.
- * @author dmulloy2
- */
-public class ProtocolLibrary {
-	/**
-	 * The minimum version ProtocolLib has been tested with.
-	 */
-	public static final String MINIMUM_MINECRAFT_VERSION = "1.8";
-
-	/**
-	 * The maximum version ProtocolLib has been tested with.
-	 */
-	public static final String MAXIMUM_MINECRAFT_VERSION = "1.11.2";
-
-	/**
-	 * The date (with ISO 8601 or YYYY-MM-DD) when the most recent version (1.11) was released.
-	 */
-	public static final String MINECRAFT_LAST_RELEASE_DATE = "2016-12-21";
-
-	/**
-	 * Plugins that are currently incompatible with ProtocolLib.
-	 */
-	public static final List<String> INCOMPATIBLE = Arrays.asList("TagAPI");
-
-	private static Plugin plugin;
-	private static ProtocolConfig config;
-	private static ProtocolManager manager;
-	private static ErrorReporter reporter = new BasicErrorReporter();
-
-	private static ListeningScheduledExecutorService executorAsync;
-	private static ListeningScheduledExecutorService executorSync;
-
-	private static boolean updatesDisabled;
-	private static boolean initialized;
-
-	protected static void init(Plugin plugin, ProtocolConfig config, ProtocolManager manager, ErrorReporter reporter,
-			ListeningScheduledExecutorService executorAsync, ListeningScheduledExecutorService executorSync) {
-		Validate.isTrue(!initialized, "ProtocolLib has already been initialized.");
-		ProtocolLibrary.plugin = plugin;
-		ProtocolLibrary.config = config;
-		ProtocolLibrary.manager = manager;
-		ProtocolLibrary.reporter = reporter;
-		ProtocolLibrary.executorAsync = executorAsync;
-		ProtocolLibrary.executorSync = executorSync;
-		initialized = true;
-	}
-
-	/**
-	 * Gets the ProtocolLib plugin instance.
-	 * @return The plugin instance
-	 */
-	public static Plugin getPlugin() {
-		return plugin;
-	}
-
-	/**
-	 * Gets ProtocolLib's configuration
-	 * @return The config
-	 */
-	public static ProtocolConfig getConfig() {
-		return config;
-	}
-
-	/**
-	 * Retrieves the packet protocol manager.
-	 * @return Packet protocol manager
-	 */
-	public static ProtocolManager getProtocolManager() {
-		return manager;
-	}
-
-	/**
-	 * Retrieve the current error reporter.
-	 * @return Current error reporter.
-	 */
-	public static ErrorReporter getErrorReporter() {
-		return reporter;
-	}
-
-	/**
-	 * Retrieve an executor service for performing asynchronous tasks on the behalf of ProtocolLib.
-	 * <p>
-	 * Note that this service is NULL if ProtocolLib has not been initialized yet.
-	 * @return The executor service, or NULL.
-	 */
-	public static ListeningScheduledExecutorService getExecutorAsync() {
-		return executorAsync;
-	}
-
-	/**
-	 * Retrieve an executor service for performing synchronous tasks (main thread) on the behalf of ProtocolLib.
-	 * <p>
-	 * Note that this service is NULL if ProtocolLib has not been initialized yet.
-	 * @return The executor service, or NULL.
-	 */
-	public static ListeningScheduledExecutorService getExecutorSync() {
-		return executorSync;
-	}
-
-	/**
-	 * Disables the ProtocolLib update checker.
-	 */
-	public static void disableUpdates() {
-		updatesDisabled = true;
-	}
-
-	/**
-	 * Whether or not updates are currently disabled.
-	 * @return True if it is, false if not
-	 */
-	public static boolean updatesDisabled() {
-		return updatesDisabled;
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/ProtocolLogger.java

@@ -1,76 +0,0 @@
-/**
- *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
- *  Copyright (C) 2016 dmulloy2
- *
- *  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;
-
-import java.text.MessageFormat;
-import java.util.logging.Level;
-
-import org.bukkit.plugin.Plugin;
-
-/**
- * @author dmulloy2
- */
-public class ProtocolLogger {
-	private static Plugin plugin;
-
-	protected static void init(Plugin plugin) {
-		ProtocolLogger.plugin = plugin;
-	}
-
-	private static boolean isDebugEnabled() {
-		try {
-			return plugin.getConfig().getBoolean("global.debug", false);
-		} catch (Throwable ex) { // Maybe we're testing or something
-			return false;
-		}
-	}
-
-	/**
-	 * Logs a message to console with a given level.
-	 * @param level Logging level
-	 * @param message Message to log
-	 * @param args Arguments to format in
-	 */
-	public static void log(Level level, String message, Object... args) {
-		plugin.getLogger().log(level, MessageFormat.format(message, args));
-	}
-
-	/**
-	 * Logs a method to console with the INFO level.
-	 * @param message Message to log
-	 * @param args Arguments to format in
-	 */
-	public static void log(String message, Object... args) {
-		log(Level.INFO, message, args);
-	}
-
-	/**
-	 * Logs a message to console with a given level and exception.
-	 * @param level Logging level
-	 * @param message Message to log
-	 * @param ex Exception to log
-	 */
-	public static void log(Level level, String message, Throwable ex) {
-		plugin.getLogger().log(level, message, ex);
-	}
-
-	public static void debug(String message, Object... args) {
-		if (isDebugEnabled()) {
-			log("[Debug] " + message, args);
-		}
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/ProtocolManager.java

@@ -1,285 +0,0 @@
-/*
- *  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;
-
-import java.lang.reflect.InvocationTargetException;
-import java.util.List;
-import java.util.Set;
-
-import org.bukkit.Location;
-import org.bukkit.World;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.Plugin;
-
-import com.comphenix.protocol.async.AsyncMarker;
-import com.comphenix.protocol.events.ListenerPriority;
-import com.comphenix.protocol.events.ListeningWhitelist;
-import com.comphenix.protocol.events.PacketContainer;
-import com.comphenix.protocol.events.PacketListener;
-import com.comphenix.protocol.injector.PacketConstructor;
-import com.comphenix.protocol.reflect.FieldAccessException;
-import com.comphenix.protocol.utility.MinecraftVersion;
-import com.google.common.collect.ImmutableSet;
-
-/**
- * Represents an API for accessing the Minecraft protocol.
- * @author Kristian
- */
-public interface ProtocolManager extends PacketStream {
-	/**
-	 * Retrieve the protocol version of a given player.
-	 * <p>
-	 * This only really makes sense of a server that support clients of multiple Minecraft versions, such as Spigot #1628.
-	 * @param player - the player.
-	 * @return The associated protocol version, or {@link Integer#MIN_VALUE} if unknown.
-	 */
-	public int getProtocolVersion(Player player);
-	
-	/**
-	 * Send a packet to the given player.
-	 * <p>
-	 * Re-sending a previously cancelled packet is discouraged. Use {@link AsyncMarker#incrementProcessingDelay()}
-	 * to delay a packet until a certain condition has been met.
-	 * 
-	 * @param receiver - the receiver.
-	 * @param packet - packet to send.
-	 * @param filters - whether or not to invoke any packet filters below {@link ListenerPriority#MONITOR}.
-	 * @throws InvocationTargetException - if an error occurred when sending the packet.
-	 */
-	@Override
-	public void sendServerPacket(Player receiver, PacketContainer packet, boolean filters)
-			throws InvocationTargetException;
-	
-	/**
-	 * Simulate receiving a certain packet from a given player.
-	 * <p>
-	 * Receiving a previously cancelled packet is discouraged. Use {@link AsyncMarker#incrementProcessingDelay()}
-	 * to delay a packet until a certain condition has been met.
-	 * 
-	 * @param sender - the sender.
-	 * @param packet - the packet that was sent.
-	 * @param filters - whether or not to invoke any packet filters below {@link ListenerPriority#MONITOR}.
-	 * @throws InvocationTargetException If the reflection machinery failed.
-	 * @throws IllegalAccessException If the underlying method caused an error.
-	 */
-	@Override
-	public void recieveClientPacket(Player sender, PacketContainer packet, boolean filters)
-			throws IllegalAccessException, InvocationTargetException;
-	
-	/**
-	 * Broadcast a given packet to every connected player on the server.
-	 * @param packet - the packet to broadcast.
-	 * @throws FieldAccessException If we were unable to send the packet due to reflection problems.
-	 */
-	public void broadcastServerPacket(PacketContainer packet);
-	
-	/**
-	 * Broadcast a packet to every player that is receiving information about a given entity.
-	 * <p>
-	 * This is usually every player in the same world within an observable distance. If the entity is a
-	 * player, it will only be included if <i>includeTracker</i> is TRUE.
-	 * @param packet - the packet to broadcast.
-	 * @param entity - the entity whose trackers we will inform.
-	 * @param includeTracker - whether or not to also transmit the packet to the entity, if it is a tracker.
-	 * @throws FieldAccessException If we were unable to send the packet due to reflection problems.
-	 */
-	public void broadcastServerPacket(PacketContainer packet, Entity entity, boolean includeTracker);
-	
-	/**
-	 * Broadcast a packet to every player within the given maximum observer distance.
-	 * @param packet - the packet to broadcast.
-	 * @param origin - the origin to consider when calculating the distance to each observer.
-	 * @param maxObserverDistance - the maximum distance to the origin.
-	 */
-	public void broadcastServerPacket(PacketContainer packet, Location origin, int maxObserverDistance);
-	
-	/**
-	 * Retrieves a list of every registered packet listener.
-	 * @return Every registered packet listener.
-	 */
-	public ImmutableSet<PacketListener> getPacketListeners();
-
-	/**
-	 * Adds a packet listener.
-	 * <p>
-	 * Adding an already registered listener has no effect. If you need to change the packets
-	 * the current listener is observing, you must first remove the packet listener before you
-	 * can register it again.
-	 * @param listener - new packet listener.
-	 */
-	public void addPacketListener(PacketListener listener);
-
-	/**
-	 * Removes a given packet listener.
-	 * <p>
-	 * Attempting to remove a listener that doesn't exist has no effect.
-	 * @param listener - the packet listener to remove.
-	 */
-	public void removePacketListener(PacketListener listener);
-
-	/**
-	 * Removes every listener associated with the given plugin.
-	 * @param plugin - the plugin to unload.
-	 */
-	public void removePacketListeners(Plugin plugin);
-
-	/**
-	 * Constructs a new encapsulated Minecraft packet with the given ID.
-	 * <p>
-	 * Deprecated: Use {@link #createPacket(PacketType)} instead.
-	 * @param id - packet ID.
-	 * @return New encapsulated Minecraft packet.
-	 */
-	@Deprecated
-	public PacketContainer createPacket(int id);
-	
-	/**
-	 * Constructs a new encapsulated Minecraft packet with the given ID.
-	 * @param  type - packet  type.
-	 * @return New encapsulated Minecraft packet.
-	 */
-	public PacketContainer createPacket(PacketType type);
-	
-	/**
-	 * Constructs a new encapsulated Minecraft packet with the given ID.
-	 * <p>
-	 * If set to true, the <i>forceDefaults</i> option will force the system to automatically
-	 * give non-primitive fields in the packet sensible default values. For instance, certain
-	 * packets - like Packet60Explosion - require a List or Set to be non-null. If the
-	 * forceDefaults option is true, the List or Set will be automatically created.
-	 * <p>
-	 * Deprecated: Use {@link #createPacket(PacketType, boolean)} instead.
-	 * 
-	 * @param id - packet ID.
-	 * @param forceDefaults - TRUE to use sensible defaults in most fields, FALSE otherwise.
-	 * @return New encapsulated Minecraft packet.
-	 */
-	@Deprecated
-	public PacketContainer createPacket(int id, boolean forceDefaults);
-	
-	/**
-	 * Constructs a new encapsulated Minecraft packet with the given ID.
-	 * <p>
-	 * If set to true, the <i>forceDefaults</i> option will force the system to automatically
-	 * give non-primitive fields in the packet sensible default values. For instance, certain
-	 * packets - like Packet60Explosion - require a List or Set to be non-null. If the
-	 * forceDefaults option is true, the List or Set will be automatically created.
-	 * 
-	 * @param type - packet type.
-	 * @param forceDefaults - TRUE to use sensible defaults in most fields, FALSE otherwise.
-	 * @return New encapsulated Minecraft packet.
-	 */
-	public PacketContainer createPacket(PacketType type, boolean forceDefaults);
-
-	/**
-	 * Construct a packet using the special builtin Minecraft constructors.
-	 * <p>
-	 * Deprecated: Use {@link #createPacketConstructor(PacketType, Object...)} instead.
-	 * @param id - the packet ID.
-	 * @param arguments - arguments that will be passed to the constructor.
-	 * @return The packet constructor.
-	 */
-	@Deprecated
-	public PacketConstructor createPacketConstructor(int id, Object... arguments);
-	
-	/**
-	 * Construct a packet using the special builtin Minecraft constructors.
-	 * @param type - the packet type.
-	 * @param arguments - arguments that will be passed to the constructor.
-	 * @return The packet constructor.
-	 */
-	public PacketConstructor createPacketConstructor(PacketType type, Object... arguments);
-	
-	/**
-	 * Completely resend an entity to a list of clients.
-	 * <p>
-	 * Note that this method is NOT thread safe. If you call this method from anything
-	 * but the main thread, it will throw an exception.
-	 * @param entity - entity to refresh.
-	 * @param observers - the clients to update.
-	 */
-	public void updateEntity(Entity entity, List<Player> observers) throws FieldAccessException;
-	
-	/**
-	 * Retrieve the associated entity.
-	 * @param container - the world the entity belongs to.
-	 * @param id - the unique ID of the entity.
-	 * @return The associated entity.
-	 * @throws FieldAccessException Reflection failed.
-	 */
-	public Entity getEntityFromID(World container, int id) throws FieldAccessException;
-	
-	/**
-	 * Retrieve every client that is receiving information about a given entity.
-	 * @param entity - the entity that is being tracked.
-	 * @return Every client/player that is tracking the given entity.
-	 * @throws FieldAccessException If reflection failed.
-	 */
-	public List<Player> getEntityTrackers(Entity entity) throws FieldAccessException;
-	
-	/**
-	 * Retrieves a immutable set containing the ID of the sent server packets that will be observed by listeners.
-	 * <p>
-	 * Deprecated: Use {@link #getSendingFilterTypes()} instead.
-	 * @return Every filtered server packet.
-	 */
-	@Deprecated
-	public Set<Integer> getSendingFilters();
-	
-	/**
-	 * Retrieves a immutable set containing the type of the sent server packets that will be observed by listeners.
-	 * @return Every filtered server packet.
-	 */
-	public Set<PacketType> getSendingFilterTypes();
-	
-	/**
-	 * Retrieves a immutable set containing the ID of the received client packets that will be observed by listeners.
-	 * <p>
-	 * Deprecated: Use {@link #getReceivingFilterTypes()} instead.
-	 * @return Every filtered client packet.
-	 */
-	@Deprecated
-	public Set<Integer> getReceivingFilters();
-	
-	/**
-	 * Retrieves a immutable set containing the type of the received client packets that will be observed by listeners.
-	 * @return Every filtered client packet.
-	 */
-	public Set<PacketType> getReceivingFilterTypes();
-	
-	/**
-	 * Retrieve the current Minecraft version.
-	 * @return The current version.
-	 */
-	public MinecraftVersion getMinecraftVersion();
-	
-	/**
-	 * Determines whether or not this protocol manager has been disabled.
-	 * @return TRUE if it has, FALSE otherwise.
-	 */
-	public boolean isClosed();
-
-	/**
-	 * Retrieve the current asynchronous packet manager.
-	 * @return Asynchronous packet manager.
-	 */
-	public AsynchronousManager getAsynchronousManager();
-
-	public void verifyWhitelist(PacketListener listener, ListeningWhitelist whitelist);
-}

modules/API/src/main/java/com/comphenix/protocol/async/AsyncFilterManager.java

@@ -1,493 +0,0 @@
-/*
- *  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.async;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.atomic.AtomicInteger;
-
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.scheduler.BukkitScheduler;
-
-import com.comphenix.protocol.AsynchronousManager;
-import com.comphenix.protocol.PacketStream;
-import com.comphenix.protocol.PacketType;
-import com.comphenix.protocol.ProtocolManager;
-import com.comphenix.protocol.error.ErrorReporter;
-import com.comphenix.protocol.events.ListeningWhitelist;
-import com.comphenix.protocol.events.PacketEvent;
-import com.comphenix.protocol.events.PacketListener;
-import com.comphenix.protocol.injector.PrioritizedListener;
-import com.comphenix.protocol.injector.SortedPacketListenerList;
-import com.comphenix.protocol.injector.packet.PacketRegistry;
-import com.google.common.base.Objects;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Sets;
-
-/**
- * Represents a filter manager for asynchronous packets.
- * <p>
- * By using {@link AsyncMarker#incrementProcessingDelay()}, a packet can be delayed without having to block the
- * processing thread.
- * @author Kristian
- */
-public class AsyncFilterManager implements AsynchronousManager {
-
-	private SortedPacketListenerList serverTimeoutListeners;
-	private SortedPacketListenerList clientTimeoutListeners;
-	private Set<PacketListener> timeoutListeners;
-	
-	private PacketProcessingQueue serverProcessingQueue;
-	private PacketProcessingQueue clientProcessingQueue;
-
-	// Sending queues
-	private final PlayerSendingHandler playerSendingHandler;
-	
-	// Report exceptions
-	private final ErrorReporter reporter;
-	
-	// The likely main thread
-	private final Thread mainThread;
-	
-	// Default scheduler
-	private final BukkitScheduler scheduler;
-	
-	// Current packet index
-	private final AtomicInteger currentSendingIndex = new AtomicInteger();
-	
-	// Our protocol manager
-	private ProtocolManager manager;
-	
-	/**
-	 * Initialize a asynchronous filter manager.
-	 * <p>
-	 * <b>Internal method</b>. Retrieve the global asynchronous manager from the protocol manager instead.
-	 * @param reporter - desired error reporter.
-	 * @param scheduler - task scheduler.
-	 */
-	public AsyncFilterManager(ErrorReporter reporter, BukkitScheduler scheduler) {
-		// Initialize timeout listeners
-		this.serverTimeoutListeners = new SortedPacketListenerList();
-		this.clientTimeoutListeners = new SortedPacketListenerList();
-		this.timeoutListeners = Sets.newSetFromMap(new ConcurrentHashMap<PacketListener, Boolean>());
-
-		this.playerSendingHandler = new PlayerSendingHandler(reporter, serverTimeoutListeners, clientTimeoutListeners);
-		this.serverProcessingQueue = new PacketProcessingQueue(playerSendingHandler);
-		this.clientProcessingQueue = new PacketProcessingQueue(playerSendingHandler);
-		this.playerSendingHandler.initializeScheduler();
-		
-		this.scheduler = scheduler;
-		this.reporter = reporter;
-		this.mainThread = Thread.currentThread();
-	}
-	
-	/**
-	 * Retrieve the protocol manager.
-	 * @return The protocol manager.
-	 */
-	public ProtocolManager getManager() {
-		return manager;
-	}
-	
-	/**
-	 * Set the associated protocol manager.
-	 * @param manager - the new manager.
-	 */
-	public void setManager(ProtocolManager manager) {
-		this.manager = manager;
-	}
-	
-	@Override
-	public AsyncListenerHandler registerAsyncHandler(PacketListener listener) {
-		return registerAsyncHandler(listener, true);
-	}
-	
-	@Override
-	public void registerTimeoutHandler(PacketListener listener) {
-		if (listener == null)
-			throw new IllegalArgumentException("listener cannot be NULL.");
-		if (!timeoutListeners.add(listener))
-			return;
-		
-		ListeningWhitelist sending = listener.getSendingWhitelist();
-		ListeningWhitelist receiving = listener.getReceivingWhitelist();
-		
-		if (!ListeningWhitelist.isEmpty(sending))
-			serverTimeoutListeners.addListener(listener, sending);
-		if (!ListeningWhitelist.isEmpty(receiving))
-			serverTimeoutListeners.addListener(listener, receiving);
-	}
-
-	@Override
-	public Set<PacketListener> getTimeoutHandlers() {
-		return ImmutableSet.copyOf(timeoutListeners);
-	}
-	
-	@Override
-	public Set<PacketListener> getAsyncHandlers() {
-		ImmutableSet.Builder<PacketListener> builder = ImmutableSet.builder();
-		
-		// Add every asynchronous packet listener
-		for (PrioritizedListener<AsyncListenerHandler> handler :
-				Iterables.concat(serverProcessingQueue.values(), clientProcessingQueue.values())) {
-			builder.add(handler.getListener().getAsyncListener());
-		}
-		return builder.build();
-	}
-	
-	/**
-	 * Registers an asynchronous packet handler.
-	 * <p>
-	 * Use {@link AsyncMarker#incrementProcessingDelay()} to delay a packet until its ready to be transmitted.
-	 * <p>
-	 * To start listening asynchronously, pass the getListenerLoop() runnable to a different thread.
-	 * <p>
-	 * Asynchronous events will only be executed if a synchronous listener with the same packets is registered.
-	 * If you already have a synchronous event, call this method with autoInject set to FALSE.
-	 * 
-	 * @param listener - the packet listener that will receive these asynchronous events.
-	 * @param autoInject - whether or not to automatically create the corresponding synchronous listener,
-	 * @return An asynchronous handler.
-	 */
-	public AsyncListenerHandler registerAsyncHandler(PacketListener listener, boolean autoInject) {
-		AsyncListenerHandler handler = new AsyncListenerHandler(mainThread, this, listener);
-		
-		ListeningWhitelist sendingWhitelist = listener.getSendingWhitelist();
-		ListeningWhitelist receivingWhitelist = listener.getReceivingWhitelist();
-		
-		if (!hasValidWhitelist(sendingWhitelist) && !hasValidWhitelist(receivingWhitelist)) {
-			throw new IllegalArgumentException("Listener has an empty sending and receiving whitelist.");
-		}
-		
-		// Add listener to either or both processing queue
-		if (hasValidWhitelist(sendingWhitelist)) {
-			manager.verifyWhitelist(listener, sendingWhitelist);
-			serverProcessingQueue.addListener(handler, sendingWhitelist);
-		}
-		if (hasValidWhitelist(receivingWhitelist)) {
-			manager.verifyWhitelist(listener, receivingWhitelist);
-			clientProcessingQueue.addListener(handler, receivingWhitelist);
-		}
-		
-		// We need a synchronized listener to get the ball rolling
-		if (autoInject) {
-			handler.setNullPacketListener(new NullPacketListener(listener));
-			manager.addPacketListener(handler.getNullPacketListener());
-		}
-		return handler;
-	}
-	
-	private boolean hasValidWhitelist(ListeningWhitelist whitelist) {
-		return whitelist != null && whitelist.getTypes().size() > 0;
-	}
-	
-	@Override
-	public void unregisterTimeoutHandler(PacketListener listener) {
-		if (listener == null)
-			throw new IllegalArgumentException("listener cannot be NULL.");
-		
-		ListeningWhitelist sending = listener.getSendingWhitelist();
-		ListeningWhitelist receiving = listener.getReceivingWhitelist();
-		
-		// Do it in the opposite order
-		if (serverTimeoutListeners.removeListener(listener, sending).size() > 0 ||
-			clientTimeoutListeners.removeListener(listener, receiving).size() > 0) {
-			timeoutListeners.remove(listener);
-		}
-	}
-	
-	@Override
-	public void unregisterAsyncHandler(PacketListener listener) {
-		if (listener == null)
-			throw new IllegalArgumentException("listener cannot be NULL.");
-		
-		AsyncListenerHandler handler =
-					  findHandler(serverProcessingQueue, listener.getSendingWhitelist(), listener);
-		
-		if (handler == null) {
-			handler = findHandler(clientProcessingQueue, listener.getReceivingWhitelist(), listener);
-		}
-		unregisterAsyncHandler(handler);
-	}
-	
-	// Search for the first correct handler
-	private AsyncListenerHandler findHandler(PacketProcessingQueue queue, ListeningWhitelist search, PacketListener target) {
-		if (ListeningWhitelist.isEmpty(search))
-			return null;
-		
-		for (PacketType type : search.getTypes()) {
-			for (PrioritizedListener<AsyncListenerHandler> element : queue.getListener(type)) {
-				if (element.getListener().getAsyncListener() == target) {
-					return element.getListener();
-				}
-			}
-		}
-		return null;
-	}
-	
-	@Override
-	public void unregisterAsyncHandler(AsyncListenerHandler handler) {
-		if (handler == null)
-			throw new IllegalArgumentException("listenerToken cannot be NULL");
-		
-		handler.cancel();
-	}
-	
-	// Called by AsyncListenerHandler
-	void unregisterAsyncHandlerInternal(AsyncListenerHandler handler) {
-		
-		PacketListener listener = handler.getAsyncListener();
-		boolean synchronusOK = onMainThread();
-		
-		// Unregister null packet listeners
-		if (handler.getNullPacketListener() != null) {
-			manager.removePacketListener(handler.getNullPacketListener());
-		}
-		
-		// Just remove it from the queue(s)
-		if (hasValidWhitelist(listener.getSendingWhitelist())) {
-			List<PacketType> removed = serverProcessingQueue.removeListener(handler, listener.getSendingWhitelist());
-			
-			// We're already taking care of this, so don't do anything
-			playerSendingHandler.sendServerPackets(removed, synchronusOK);
-		}
-		
-		if (hasValidWhitelist(listener.getReceivingWhitelist())) {
-			List<PacketType> removed = clientProcessingQueue.removeListener(handler, listener.getReceivingWhitelist());
-			playerSendingHandler.sendClientPackets(removed, synchronusOK);
-		}
-	}
-	
-	/**
-	 * Determine if we're running on the main thread.
-	 * @return TRUE if we are, FALSE otherwise.
-	 */
-	private boolean onMainThread() {
-		return Thread.currentThread().getId() == mainThread.getId();
-	}
-	
-	@Override
-	public void unregisterAsyncHandlers(Plugin plugin) {
-		unregisterAsyncHandlers(serverProcessingQueue, plugin);
-		unregisterAsyncHandlers(clientProcessingQueue, plugin);
-	}
-	
-	private void unregisterAsyncHandlers(PacketProcessingQueue processingQueue, Plugin plugin) {
-		
-		// Iterate through every packet listener
-		for (PrioritizedListener<AsyncListenerHandler> listener : processingQueue.values()) {
-			// Remove the listener
-			if (Objects.equal(listener.getListener().getPlugin(), plugin)) {
-				unregisterAsyncHandler(listener.getListener());
-			}
-		}
-	}
-	
-	/**
-	 * Enqueue a packet for asynchronous processing.
-	 * 
-	 * @param syncPacket - synchronous packet event.
-	 * @param asyncMarker - the asynchronous marker to use.
-	 */
-	public synchronized void enqueueSyncPacket(PacketEvent syncPacket, AsyncMarker asyncMarker) {
-		PacketEvent newEvent = PacketEvent.fromSynchronous(syncPacket, asyncMarker);
-
-		if (asyncMarker.isQueued() || asyncMarker.isTransmitted())
-			throw new IllegalArgumentException("Cannot queue a packet that has already been queued.");
-
-		asyncMarker.setQueuedSendingIndex(asyncMarker.getNewSendingIndex());
-
-		// The player is only be null when they're logged out,
-		// so this should be a pretty safe check
-		Player player = newEvent.getPlayer();
-		if (player != null) {
-			// Start the process
-			getSendingQueue(syncPacket).enqueue(newEvent);
-
-			// We know this is occuring on the main thread, so pass TRUE
-			getProcessingQueue(syncPacket).enqueue(newEvent, true);
-		}
-	}
-	
-	@Override
-	public Set<Integer> getSendingFilters() {
-		return PacketRegistry.toLegacy(serverProcessingQueue.keySet());
-	}
-	
-	@Override
-	public Set<PacketType> getReceivingTypes() {
-		return serverProcessingQueue.keySet();
-	}
-	
-	@Override
-	public Set<Integer> getReceivingFilters() {
-		return PacketRegistry.toLegacy(clientProcessingQueue.keySet());
-	}
-	
-	@Override
-	public Set<PacketType> getSendingTypes() {
-		return clientProcessingQueue.keySet();
-	}
-	
-	/**
-	 * Retrieve the current task scheduler.
-	 * @return Current task scheduler.
-	 */
-	public BukkitScheduler getScheduler() {
-		return scheduler;
-	}
-	
-	@Override
-	public boolean hasAsynchronousListeners(PacketEvent packet) {
-		 Collection<?> list = getProcessingQueue(packet).getListener(packet.getPacketType());
-		 return list != null && list.size() > 0;
-	}
-	
-	/**
-	 * Construct a asynchronous marker with all the default values.
-	 * @return Asynchronous marker.
-	 */
-	public AsyncMarker createAsyncMarker() {
-		return createAsyncMarker(AsyncMarker.DEFAULT_TIMEOUT_DELTA);
-	}
-	
-	/**
-	 * Construct an async marker with the given sending priority delta and timeout delta.
-	 * @param timeoutDelta - how long (in ms) until the packet expire.
-	 * @return An async marker.
-	 */
-	public AsyncMarker createAsyncMarker(long timeoutDelta) {
-		return createAsyncMarker(timeoutDelta, currentSendingIndex.incrementAndGet());
-	}
-	
-	// Helper method
-	private AsyncMarker createAsyncMarker(long timeoutDelta, long sendingIndex) {
-		return new AsyncMarker(manager, sendingIndex, System.currentTimeMillis(), timeoutDelta);
-	}
-	
-	@Override
-	public PacketStream getPacketStream() {
-		return manager;
-	}
-
-	@Override
-	public ErrorReporter getErrorReporter() {
-		return reporter;
-	}
-	
-	@Override
-	public void cleanupAll() {
-		serverProcessingQueue.cleanupAll();
-		playerSendingHandler.cleanupAll();
-		timeoutListeners.clear();
-		
-		serverTimeoutListeners = null;
-		clientTimeoutListeners = null;
-	}
-	
-	@Override
-	public void signalPacketTransmission(PacketEvent packet) {
-		signalPacketTransmission(packet, onMainThread());
-	}
-
-	/**
-	 * Signal that a packet is ready to be transmitted.
-	 * @param packet - packet to signal.
-	 * @param onMainThread - whether or not this method was run by the main thread.
-	 */
-	private void signalPacketTransmission(PacketEvent packet, boolean onMainThread) {
-		AsyncMarker marker = packet.getAsyncMarker();
-		if (marker == null)
-			throw new IllegalArgumentException(
-					"A sync packet cannot be transmitted by the asynchronous manager.");
-		if (!marker.isQueued())
-			throw new IllegalArgumentException(
-					"A packet must have been queued before it can be transmitted.");
-		
-		// Only send if the packet is ready
-		if (marker.decrementProcessingDelay() == 0) {
-			PacketSendingQueue queue = getSendingQueue(packet, false);
-			
-			// No need to create a new queue if the player has logged out
-			if (queue != null)
-				queue.signalPacketUpdate(packet, onMainThread);
-		}
-	}
-	
-	/**
-	 * Retrieve the sending queue this packet belongs to.
-	 * @param packet - the packet.
-	 * @return The server or client sending queue the packet belongs to.
-	 */
-	public PacketSendingQueue getSendingQueue(PacketEvent packet) {
-		return playerSendingHandler.getSendingQueue(packet);
-	}
-	
-	/**
-	 * Retrieve the sending queue this packet belongs to.
-	 * @param packet - the packet.
-	 * @param createNew - if TRUE, create a new queue if it hasn't already been created.
-	 * @return The server or client sending queue the packet belongs to.
-	 */
-	public PacketSendingQueue getSendingQueue(PacketEvent packet, boolean createNew) {
-		return playerSendingHandler.getSendingQueue(packet, createNew);
-	}
-	
-	/**
-	 * Retrieve the processing queue this packet belongs to.
-	 * @param packet - the packet.
-	 * @return The server or client sending processing the packet belongs to.
-	 */
-	public PacketProcessingQueue getProcessingQueue(PacketEvent packet) {
-		return packet.isServerPacket() ? serverProcessingQueue : clientProcessingQueue;
-	}
-	
-	/**
-	 * Signal that a packet has finished processing.
-	 * @param packet - packet to signal.
-	 */
-	public void signalFreeProcessingSlot(PacketEvent packet) {
-		getProcessingQueue(packet).signalProcessingDone();
-	}
-	
-	/**
-	 * Send any due packets, or clean up packets that have expired.
-	 * @param tickCounter Tick counter
-	 * @param onMainThread Whether or not to execute on the main thread
-	 */
-	public void sendProcessedPackets(int tickCounter, boolean onMainThread) {
-		// The server queue is unlikely to need checking that often
-		if (tickCounter % 10 == 0) {
-			playerSendingHandler.trySendServerPackets(onMainThread);
-		}
-		
-		playerSendingHandler.trySendClientPackets(onMainThread);
-	}
-
-	/**
-	 * Clean up after a given player has logged out.
-	 * @param player - the player that has just logged out.
-	 */
-	public void removePlayer(Player player) {
-		playerSendingHandler.removePlayer(player);
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/async/AsyncListenerHandler.java

@@ -1,706 +0,0 @@
-/*
- *  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.async;
-
-import java.util.HashSet;
-import java.util.Set;
-import java.util.concurrent.ArrayBlockingQueue;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
-
-import org.bukkit.plugin.Plugin;
-
-import com.comphenix.protocol.ProtocolLibrary;
-import com.comphenix.protocol.error.Report;
-import com.comphenix.protocol.error.ReportType;
-import com.comphenix.protocol.events.ListeningWhitelist;
-import com.comphenix.protocol.events.PacketAdapter;
-import com.comphenix.protocol.events.PacketEvent;
-import com.comphenix.protocol.events.PacketListener;
-import com.comphenix.protocol.timing.TimedListenerManager;
-import com.comphenix.protocol.timing.TimedListenerManager.ListenerType;
-import com.comphenix.protocol.timing.TimedTracker;
-import com.comphenix.protocol.utility.WrappedScheduler;
-import com.google.common.base.Function;
-import com.google.common.base.Joiner;
-
-/**
- * Represents a handler for an asynchronous event.
- * <p>
- * Use {@link AsyncMarker#incrementProcessingDelay()} to delay a packet until a certain condition has been met.
- * @author Kristian
- */
-public class AsyncListenerHandler {
-	public static final ReportType REPORT_HANDLER_NOT_STARTED = new ReportType(
-		"Plugin %s did not start the asynchronous handler %s by calling start() or syncStart().");
-
-	/**
-	 * Signal an end to packet processing.
-	 */
-	private static final PacketEvent INTERUPT_PACKET = new PacketEvent(new Object());
-	
-	/**
-	 * Called when the threads have to wake up for something important.
-	 */
-	private static final PacketEvent WAKEUP_PACKET = new PacketEvent(new Object());
-	
-	/**
-	 * The expected number of ticks per second.
-	 */
-	private static final int TICKS_PER_SECOND = 20;
-	
-	// Unique worker ID
-	private static final AtomicInteger nextID = new AtomicInteger();
-	
-	// Default queue capacity
-	private static final int DEFAULT_CAPACITY = 1024;
-	
-	// Cancel the async handler
-	private volatile boolean cancelled;
-	
-	// Number of worker threads
-	private final AtomicInteger started = new AtomicInteger();
-	
-	// The packet listener
-	private PacketListener listener;
-
-	// The filter manager
-	private AsyncFilterManager filterManager;
-	private NullPacketListener nullPacketListener;
-	
-	// List of queued packets
-	private ArrayBlockingQueue<PacketEvent> queuedPackets = new ArrayBlockingQueue<PacketEvent>(DEFAULT_CAPACITY);
-	
-	// List of cancelled tasks
-	private final Set<Integer> stoppedTasks = new HashSet<Integer>();
-	private final Object stopLock = new Object();
-	
-	// Processing task on the main thread
-	private int syncTask = -1;
-	
-	// Minecraft main thread
-	private Thread mainThread;
-	
-	// Warn plugins that the async listener handler must be started
-	private int warningTask;
-	
-	// Timing manager
-	private TimedListenerManager timedManager = TimedListenerManager.getInstance();
-	
-	/**
-	 * Construct a manager for an asynchronous packet handler.
-	 * @param mainThread - the main game thread.
-	 * @param filterManager - the parent filter manager.
-	 * @param listener - the current packet listener.
-	 */
-	AsyncListenerHandler(Thread mainThread, AsyncFilterManager filterManager, PacketListener listener) {
-		if (filterManager == null)
-			throw new IllegalArgumentException("filterManager cannot be NULL");
-		if (listener == null)
-			throw new IllegalArgumentException("listener cannot be NULL");
-
-		this.mainThread = mainThread;
-		this.filterManager = filterManager;
-		this.listener = listener;
-		startWarningTask();
-	}
-	
-	private void startWarningTask() {
-		warningTask = filterManager.getScheduler().scheduleSyncDelayedTask(getPlugin(), new Runnable() {
-			@Override
-			public void run() {
-				ProtocolLibrary.getErrorReporter().reportWarning(AsyncListenerHandler.this, Report.
-						newBuilder(REPORT_HANDLER_NOT_STARTED).
-						messageParam(listener.getPlugin(), AsyncListenerHandler.this).
-						build()
-				);
-			}
-		}, 2 * TICKS_PER_SECOND);
-	}
-	
-	private void stopWarningTask() {
-		int taskId = warningTask;
-		
-		// Ensure we have a task to cancel
-		if (warningTask >= 0) {
-			filterManager.getScheduler().cancelTask(taskId);
-			warningTask = -1;
-		}
-	}
-	
-	/**
-	 * Determine whether or not this asynchronous handler has been cancelled.
-	 * @return TRUE if it has been cancelled/stopped, FALSE otherwise.
-	 */
-	public boolean isCancelled() {
-		return cancelled;
-	}
-
-	/**
-	 * Retrieve the current asynchronous packet listener.
-	 * @return Current packet listener.
-	 */
-	public PacketListener getAsyncListener() {
-		return listener;
-	}
-
-	/**
-	 * Set the synchronized listener that has been automatically created.
-	 * @param nullPacketListener - automatically created listener.
-	 */
-	void setNullPacketListener(NullPacketListener nullPacketListener) {
-		this.nullPacketListener = nullPacketListener;
-	}
-
-	/**
-	 * Retrieve the synchronized listener that was automatically created.
-	 * @return Automatically created listener.
-	 */
-	PacketListener getNullPacketListener() {
-		return nullPacketListener;
-	}
-
-	/**
-	 * Retrieve the plugin associated with this async listener.
-	 * @return The plugin.
-	 */
-	public Plugin getPlugin() {
-		return listener != null ? listener.getPlugin() : null;
-	}
-	
-	/**
-	 * Cancel the handler.
-	 */
-	public void cancel() {
-		// Remove the listener as quickly as possible
-		close();
-	}
-
-	/**
-	 * Queue a packet for processing.
-	 * @param packet - a packet for processing.
-	 * @throws IllegalStateException If the underlying packet queue is full.
-	 */
-	public void enqueuePacket(PacketEvent packet) {
-		if (packet == null)
-			throw new IllegalArgumentException("packet is NULL");
-		
-		queuedPackets.add(packet);
-	}
-	
-	/**
-	 * Create a worker that will initiate the listener loop. Note that using stop() to
-	 * close a specific worker is less efficient than stopping an arbitrary worker.
-	 * <p>
-	 * <b>Warning</b>: Never call the run() method in the main thread.
-	 * @return The listener loop
-	 */
-	public AsyncRunnable getListenerLoop() {
-		return new AsyncRunnable() {
-
-			private final AtomicBoolean firstRun = new AtomicBoolean();
-			private final AtomicBoolean finished = new AtomicBoolean();
-			private final int id = nextID.incrementAndGet();
-			
-			@Override
-			public int getID() {
-				return id;
-			}
-			
-			@Override
-			public void run() {
-				// Careful now
-				if (firstRun.compareAndSet(false, true)) {
-					listenerLoop(id);
-					
-					synchronized (stopLock) {
-						stoppedTasks.remove(id);
-						stopLock.notifyAll();
-						finished.set(true);
-					}
-					
-				} else {
-					if (finished.get())
-						throw new IllegalStateException(
-							"This listener has already been run. Create a new instead.");
-					else
-						throw new IllegalStateException(
-							"This listener loop has already been started. Create a new instead.");
-				}
-			}
-			
-			@Override
-			public boolean stop() throws InterruptedException {
-				synchronized (stopLock) {
-					if (!isRunning())
-						return false;
-
-					stoppedTasks.add(id);
-			
-					// Wake up threads - we have a listener to stop
-					for (int i = 0; i < getWorkers(); i++) {
-						queuedPackets.offer(WAKEUP_PACKET);
-					}
-					
-					finished.set(true);
-					waitForStops();
-					return true;
-				}
-			}
-
-			@Override
-			public boolean isRunning() {
-				return firstRun.get() && !finished.get();
-			}
-			
-			@Override
-			public boolean isFinished() {
-				return finished.get();
-			}
-		};
-	}
-	
-	/**
-	 * Start a singler worker thread handling the asynchronous listener.
-	 */
-	public synchronized void start() {
-		if (listener.getPlugin() == null)
-			throw new IllegalArgumentException("Cannot start task without a valid plugin.");
-		if (cancelled)
-			throw new IllegalStateException("Cannot start a worker when the listener is closing.");
-		
-		final AsyncRunnable listenerLoop = getListenerLoop();
-		
-		stopWarningTask();
-		scheduleAsync(new Runnable() {
-			@Override
-			public void run() {
-				Thread thread = Thread.currentThread();
-				
-				String previousName = thread.getName();
-				String workerName = getFriendlyWorkerName(listenerLoop.getID());
-
-				// Add the friendly worker name
-				thread.setName(workerName);
-				listenerLoop.run();
-				thread.setName(previousName);
-			}
-		});
-	}
-	
-	/**
-	 * Start a singler worker thread handling the asynchronous listener.
-	 * <p>
-	 * This method is intended to allow callers to customize the thread priority
-	 * before the worker loop is actually called. This is simpler than to
-	 * schedule the worker threads manually.
-	 * <pre><code>
-	 * listenerHandler.start(new Function&lt;AsyncRunnable, Void&gt;() {
-	 *     &#64;Override
-	 *     public Void apply(&#64;Nullable AsyncRunnable workerLoop) {
-	 *         Thread thread = Thread.currentThread();
-	 *         int prevPriority = thread.getPriority();
-	 *	
-	 *         thread.setPriority(Thread.MIN_PRIORITY);
-	 *         workerLoop.run();
-	 *         thread.setPriority(prevPriority);
-	 *         return null;
-	 *     }
-	 *   });
-	 * }
-	 * </code></pre>
-	 * @param executor - a method that will execute the given listener loop.
-	 */
-	public synchronized void start(Function<AsyncRunnable, Void> executor) {
-		if (listener.getPlugin() == null)
-			throw new IllegalArgumentException("Cannot start task without a valid plugin.");
-		if (cancelled)
-			throw new IllegalStateException("Cannot start a worker when the listener is closing.");
-		
-		final AsyncRunnable listenerLoop = getListenerLoop();
-		final Function<AsyncRunnable, Void> delegateCopy = executor;
-		
-		scheduleAsync(new Runnable() {
-			@Override
-			public void run() {
-				delegateCopy.apply(listenerLoop);
-			}
-		});
-	}
-	
-	private void scheduleAsync(Runnable runnable) {
-		// Handle deprecation
-		WrappedScheduler.runAsynchronouslyRepeat(listener.getPlugin(), filterManager.getScheduler(), runnable, 0L, -1L);
-	}
-	
-	/**
-	 * Create a friendly thread name using the following convention:
-	 * <p><code>
-	 * &nbsp;&nbsp;&nbsp;&nbsp;Protocol Worker {id} - {plugin} - [recv: {packets}, send: {packets}]
-	 * </code></p>
-	 * @param id - the worker ID.
-	 * @return A friendly thread name.
-	 */
-	public String getFriendlyWorkerName(int id) {
-		return String.format("Protocol Worker #%s - %s - [recv: %s, send: %s]",
-				id,
-				PacketAdapter.getPluginName(listener),
-				fromWhitelist(listener.getReceivingWhitelist()),
-				fromWhitelist(listener.getSendingWhitelist())
-		);
-	}
-	
-	/**
-	 * Convert the given whitelist to a comma-separated list of packet IDs.
-	 * @param whitelist - the whitelist.
-	 * @return A comma separated list of packet IDs in the whitelist, or the emtpy string.
-	 */
-	private String fromWhitelist(ListeningWhitelist whitelist) {
-		if (whitelist == null)
-			return "";
-		else
-			return Joiner.on(", ").join(whitelist.getTypes());
-	}
-	
-	/**
-	 * Start processing packets on the main thread.
-	 * <p>
-	 * This is useful if you need to synchronize with the main thread in your packet listener, but
-	 * you're not performing any expensive processing.
-	 * <p>
-	 * <b>Note</b>: Use a asynchronous worker if the packet listener may use more than 0.5 ms
-	 * of processing time on a single packet. Do as much as possible on the worker thread, and schedule synchronous tasks
-	 * to use the Bukkit API instead.
-	 * @return TRUE if the synchronized processing was successfully started, FALSE if it's already running.
-	 * @throws IllegalStateException If we couldn't start the underlying task.
-	 */
-	public synchronized boolean syncStart() {
-		return syncStart(500, TimeUnit.MICROSECONDS);
-	}
-	
-	/**
-	 * Start processing packets on the main thread.
-	 * <p>
-	 * This is useful if you need to synchronize with the main thread in your packet listener, but
-	 * you're not performing any expensive processing.
-	 * <p>
-	 * The processing time parameter gives the upper bound for the amount of time spent processing pending packets.
-	 * It should be set to a fairly low number, such as 0.5 ms or 1% of a game tick - to reduce the impact
-	 * on the main thread. Never go beyond 50 milliseconds.
-	 * <p>
-	 * <b>Note</b>: Use a asynchronous worker if the packet listener may exceed the ideal processing time
-	 * on a single packet. Do as much as possible on the worker thread, and schedule synchronous tasks
-	 * to use the Bukkit API instead.
-	 * 
-	 * @param time - the amount of processing time alloted per game tick (20 ticks per second).
-	 * @param unit - the unit of the processingTime argument.
-	 * @return TRUE if the synchronized processing was successfully started, FALSE if it's already running.
-	 * @throws IllegalStateException If we couldn't start the underlying task.
-	 */
-	public synchronized boolean syncStart(final long time, final TimeUnit unit) {
-		if (time <= 0)
-			throw new IllegalArgumentException("Time must be greater than zero.");
-		if (unit == null)
-			throw new IllegalArgumentException("TimeUnit cannot be NULL.");
-	
-		final long tickDelay = 1;
-		final int workerID = nextID.incrementAndGet();
-		
-		if (syncTask < 0) {
-			stopWarningTask();
-			
-			syncTask = filterManager.getScheduler().scheduleSyncRepeatingTask(getPlugin(), new Runnable() {
-				@Override
-				public void run() {
-					long stopTime = System.nanoTime() + unit.convert(time, TimeUnit.NANOSECONDS);
-					
-					while (!cancelled) {
-						PacketEvent packet = queuedPackets.poll();
-						
-						if (packet == INTERUPT_PACKET || packet == WAKEUP_PACKET) {
-							// Sorry, asynchronous threads!
-							queuedPackets.add(packet);
-							
-							// Try again next tick
-							break;
-						} else if (packet != null && packet.getAsyncMarker() != null) {
-							processPacket(workerID, packet, "onSyncPacket()");
-						} else {
-							// No more packets left - wait a tick
-							break;
-						}
-						
-						// Check time here, ensuring that we at least process one packet
-						if (System.nanoTime() < stopTime)
-							break;
-					}
-				}
-			}, tickDelay, tickDelay);
-			
-			// This is very bad - force the caller to handle it
-			if (syncTask < 0)
-				throw new IllegalStateException("Cannot start synchronous task.");
-			else
-				return true;
-		} else {
-			return false;
-		}
-	}
-	
-	/**
-	 * Stop processing packets on the main thread.
-	 * @return TRUE if we stopped any processing tasks, FALSE if it has already been stopped.
-	 */
-	public synchronized boolean syncStop() {
-		if (syncTask > 0) {
-			filterManager.getScheduler().cancelTask(syncTask);
-			
-			syncTask = -1;
-			return true;
-		} else {
-			return false;
-		}
-	}
-	
-	/**
-	 * Start multiple worker threads for this listener.
-	 * @param count - number of worker threads to start.
-	 */
-	public synchronized void start(int count) {
-		for (int i = 0; i < count; i++)
-			start();
-	}
-	
-	/**
-	 * Stop a worker thread.
-	 */
-	public synchronized void stop() {
-		queuedPackets.add(INTERUPT_PACKET);
-	}
-	
-	/**
-	 * Stop the given amount of worker threads.
-	 * @param count - number of threads to stop.
-	 */
-	public synchronized void stop(int count) {
-		for (int i = 0; i < count; i++)
-			stop();
-	}
-	
-	/**
-	 * Set the current number of workers.
-	 * <p>
-	 * This method can only be called with a count of zero when the listener is closing.
-	 * @param count - new number of workers.
-	 */
-	public synchronized void setWorkers(int count) {
-		if (count < 0)
-			throw new IllegalArgumentException("Number of workers cannot be less than zero.");
-		if (count > DEFAULT_CAPACITY)
-			throw new IllegalArgumentException("Cannot initiate more than " + DEFAULT_CAPACITY + " workers");
-		if (cancelled && count > 0)
-			throw new IllegalArgumentException("Cannot add workers when the listener is closing.");
-		
-		long time = System.currentTimeMillis();
-		
-		// Try to get to the correct count
-		while (started.get() != count) {
-			if (started.get() < count)
-				start();
-			else
-				stop();
-			
-			// May happen if another thread is doing something similar to "setWorkers"
-			if ((System.currentTimeMillis() - time) > 50)
-				throw new RuntimeException("Failed to set worker count.");
-		}
-	}
-	
-	/**
-	 * Retrieve the current number of registered workers.
-	 * <p>
-	 * Note that the returned value may be out of data.
-	 * @return Number of registered workers.
-	 */
-	public synchronized int getWorkers() {
-		return started.get();
-	}
-	
-	/**
-	 * Wait until every tasks scheduled to stop has actually stopped.
-	 * @return TRUE if the current listener should stop, FALSE otherwise.
-	 * @throws InterruptedException - If the current thread was interrupted.
-	 */
-	private boolean waitForStops() throws InterruptedException {
-		synchronized (stopLock) {
-			while (stoppedTasks.size() > 0 && !cancelled) {
-				stopLock.wait();
-			}
-			return cancelled;
-		}
-	}
-	
-	/**
-	 * The main processing loop of asynchronous threads.
-	 * <p>
-	 * Note: DO NOT call this method from the main thread
-	 * @param workerID - the current worker ID.
-	 */
-	private void listenerLoop(int workerID) {
-		// Danger, danger!
-		if (Thread.currentThread().getId() == mainThread.getId())
-			throw new IllegalStateException("Do not call this method from the main thread.");
-		if (cancelled)
-			throw new IllegalStateException("Listener has been cancelled. Create a new listener instead.");
-
-		try {
-			// Wait if certain threads are stopping
-			if (waitForStops())
-				return;
-			
-			// Proceed
-			started.incrementAndGet();
-			
-			while (!cancelled) {
-				PacketEvent packet = queuedPackets.take();
-				
-				// Handle cancel requests
-				if (packet == WAKEUP_PACKET) {
-					// This is a bit slow, but it should be safe
-					synchronized (stopLock) {
-						// Are we the one who is supposed to stop?
-						if (stoppedTasks.contains(workerID))
-							return;
-						if (waitForStops())
-							return;
-					}
-				} else if (packet == INTERUPT_PACKET) {
-					return;
-				}
-				
-				if (packet != null && packet.getAsyncMarker() != null) {
-					processPacket(workerID, packet, "onAsyncPacket()");
-				}
-			}
-			
-		} catch (InterruptedException e) {
-			// We're done
-		} finally {
-			// Clean up
-			started.decrementAndGet();
-		}
-	}
-	
-	/**
-	 * Called when a packet is scheduled for processing.
-	 * @param workerID - the current worker ID.
-	 * @param packet - the current packet.
-	 * @param methodName - name of the method.
-	 */
-	private void processPacket(int workerID, PacketEvent packet, String methodName) {
-		AsyncMarker marker = packet.getAsyncMarker();
-		
-		// Here's the core of the asynchronous processing
-		try {
-			synchronized (marker.getProcessingLock()) {
-				marker.setListenerHandler(this);
-				marker.setWorkerID(workerID);
-				
-				// We're not THAT worried about performance here
-				if (timedManager.isTiming()) {
-					// Retrieve the tracker to use
-					TimedTracker tracker = timedManager.getTracker(listener,
-						packet.isServerPacket() ? ListenerType.ASYNC_SERVER_SIDE : ListenerType.ASYNC_CLIENT_SIDE);
-					long token = tracker.beginTracking();
-					
-					if (packet.isServerPacket())
-						listener.onPacketSending(packet);
-					else
-						listener.onPacketReceiving(packet);
-					
-					// And we're done
-					tracker.endTracking(token, packet.getPacketType());
-					
-				} else {
-					if (packet.isServerPacket())
-						listener.onPacketSending(packet);
-					else
-						listener.onPacketReceiving(packet);
-				}
-			}
-			
-		} catch (OutOfMemoryError e) {
-			throw e;
-		} catch (ThreadDeath e) {
-			throw e;
-		} catch (Throwable e) {
-			// Minecraft doesn't want your Exception.
-			filterManager.getErrorReporter().reportMinimal(listener.getPlugin(), methodName, e);
-		}
-		
-		// Now, get the next non-cancelled listener
-		if (!marker.hasExpired()) {
-			for (; marker.getListenerTraversal().hasNext(); ) {
-				AsyncListenerHandler handler = marker.getListenerTraversal().next().getListener();
-				
-				if (!handler.isCancelled()) {
-					handler.enqueuePacket(packet);
-					return;
-				}
-			}
-		}
-		
-		// There are no more listeners - queue the packet for transmission
-		filterManager.signalFreeProcessingSlot(packet);
-		
-		// Note that listeners can opt to delay the packet transmission
-		filterManager.signalPacketTransmission(packet);
-	}
-	
-	/**
-	 * Close all worker threads and the handler itself.
-	 */
-	private synchronized void close() {
-		// Remove the listener itself
-		if (!cancelled) {
-			filterManager.unregisterAsyncHandlerInternal(this);
-			cancelled = true;
-			
-			// Close processing tasks
-			syncStop();
-			
-			// Tell every uncancelled thread to end
-			stopThreads();
-		}
-	}
-	
-	/**
-	 * Use the poision pill method to stop every worker thread.
-	 */
-	private void stopThreads() {
-		// Poison Pill Shutdown
-		queuedPackets.clear();
-		stop(started.get());
-		
-		// Individual shut down is irrelevant now
-		synchronized (stopLock) {
-			stopLock.notifyAll();
-		}
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/async/AsyncMarker.java

@@ -1,487 +0,0 @@
-/*
- *  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.async;
-
-import java.io.IOException;
-import java.io.Serializable;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.Iterator;
-import java.util.List;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.logging.Level;
-
-import com.comphenix.protocol.PacketStream;
-import com.comphenix.protocol.PacketType;
-import com.comphenix.protocol.ProtocolLogger;
-import com.comphenix.protocol.events.NetworkMarker;
-import com.comphenix.protocol.events.PacketEvent;
-import com.comphenix.protocol.injector.PrioritizedListener;
-import com.comphenix.protocol.reflect.FieldAccessException;
-import com.comphenix.protocol.reflect.FuzzyReflection;
-import com.comphenix.protocol.utility.MinecraftReflection;
-import com.comphenix.protocol.utility.MinecraftVersion;
-import com.google.common.primitives.Longs;
-
-/**
- * Contains information about the packet that is being processed by asynchronous listeners.
- * <p>
- * Asynchronous listeners can use this to set packet timeout or transmission order.
- * 
- * @author Kristian
- */
-public class AsyncMarker implements Serializable, Comparable<AsyncMarker> {
-		
-	/**
-	 * Generated by Eclipse.
-	 */
-	private static final long serialVersionUID = -2621498096616187384L;
-
-	/**
-	 * Default number of milliseconds until a packet will rejected.
-	 */
-	public static final int DEFAULT_TIMEOUT_DELTA = 1800 * 1000;
-	
-	/**
-	 * Default number of packets to skip.
-	 */
-	public static final int DEFAULT_SENDING_DELTA = 0;
-	
-	/**
-	 * The packet stream responsible for transmitting the packet when it's done processing.
-	 */
-	private transient PacketStream packetStream;
-	
-	/**
-	 * Current list of async packet listeners.
-	 */
-	private transient Iterator<PrioritizedListener<AsyncListenerHandler>> listenerTraversal;
-	
-	// Timeout handling
-	private long initialTime;
-	private long timeout;
-	
-	// Packet order
-	private long originalSendingIndex;
-	private long newSendingIndex;
-	
-	// Used to determine if a packet must be reordered in the sending queue
-	private Long queuedSendingIndex;
-	
-	// Whether or not the packet has been processed by the listeners
-	private volatile boolean processed;
-	
-	// Whether or not the packet has been sent
-	private volatile boolean transmitted;
-	
-	// Whether or not the asynchronous processing itself should be cancelled
-	private volatile boolean asyncCancelled;
-	
-		// Whether or not to delay processing
-	private AtomicInteger processingDelay = new AtomicInteger();
-	
-	// Used to synchronize processing on the shared PacketEvent
-	private Object processingLock = new Object();
-	
-	// Used to identify the asynchronous worker
-	private transient AsyncListenerHandler listenerHandler;
-	private transient int workerID;
-	
-	// Determine if Minecraft processes this packet asynchronously
-	private volatile static Method isMinecraftAsync;
-	private volatile static boolean alwaysSync;
-
-	/**
-	 * Create a container for asyncronous packets.
-	 * @param initialTime - the current time in milliseconds since 01.01.1970 00:00.
-	 */
-	AsyncMarker(PacketStream packetStream, long sendingIndex, long initialTime, long timeoutDelta) {
-		if (packetStream == null)
-			throw new IllegalArgumentException("packetStream cannot be NULL");
-		
-		this.packetStream = packetStream;
-		
-		// Timeout
-		this.initialTime = initialTime;
-		this.timeout = initialTime + timeoutDelta;
-		
-		// Sending index
-		this.originalSendingIndex = sendingIndex;
-		this.newSendingIndex = sendingIndex;
-	}
-	
-	/**
-	 * Retrieve the time the packet was initially queued for asynchronous processing.
-	 * @return The initial time in number of milliseconds since 01.01.1970 00:00.
-	 */
-	public long getInitialTime() {
-		return initialTime;
-	}
-
-	/**
-	 * Retrieve the time the packet will be forcefully rejected.
-	 * @return The time to reject the packet, in milliseconds since 01.01.1970 00:00.
-	 */
-	public long getTimeout() {
-		return timeout;
-	}
-	
-	/**
-	 * Set the time the packet will be forcefully rejected.
-	 * @param timeout - time to reject the packet, in milliseconds since 01.01.1970 00:00.
-	 */
-	public void setTimeout(long timeout) {
-		this.timeout = timeout;
-	}
-
-	/**
-	 * Retrieve the order the packet was originally transmitted.
-	 * @return The original packet index.
-	 */
-	public long getOriginalSendingIndex() {
-		return originalSendingIndex;
-	}
-
-	/**
-	 * Retrieve the desired sending order after processing has completed.
-	 * <p>
-	 * Higher sending order means lower priority.
-	 * @return Desired sending order.
-	 */
-	public long getNewSendingIndex() {
-		return newSendingIndex;
-	}
-
-	/**
-	 * Sets the desired sending order after processing has completed.
-	 * <p>
-	 * Higher sending order means lower priority.
-	 * @param newSendingIndex - new packet send index.
-	 */
-	public void setNewSendingIndex(long newSendingIndex) {
-		this.newSendingIndex = newSendingIndex;
-	}
-
-	/**
-	 * Retrieve the packet stream responsible for transmitting this packet.
-	 * @return The packet stream.
-	 */
-	public PacketStream getPacketStream() {
-		return packetStream;
-	}
-
-	/**
-	 * Sets the output packet stream responsible for transmitting this packet.
-	 * @param packetStream - new output packet stream.
-	 */
-	public void setPacketStream(PacketStream packetStream) {
-		this.packetStream = packetStream;
-	}
-
-	/**
-	 * Retrieve whether or not this packet has been processed by the async listeners.
-	 * @return TRUE if it has been processed, FALSE otherwise.
-	 */
-	public boolean isProcessed() {
-		return processed;
-	}
-
-	/**
-	 * Sets whether or not this packet has been processed by the async listeners.
-	 * @param processed - TRUE if it has, FALSE otherwise.
-	 */
-	void setProcessed(boolean processed) {
-		this.processed = processed;
-	}
-
-	/**
-	 * Increment the number of times the current packet must be signalled as done before its transmitted.
-	 * <p>
-	 * This is useful if an asynchronous listener is waiting for further information before the
-	 * packet can be sent to the user. A packet listener <b>MUST</b> eventually call
-	 * {@link AsyncFilterManager#signalPacketTransmission(PacketEvent)},
-	 * even if the packet is cancelled, after this method is called.
-	 * <p>
-	 * It is recommended that processing outside a packet listener is wrapped in a synchronized block
-	 * using the {@link #getProcessingLock()} method.
-	 * 
-	 * @return The new processing delay.
-	 */
-	public int incrementProcessingDelay() {
-		return processingDelay.incrementAndGet();
-	}
-	
-	/**
-	 * Decrement the number of times this packet must be signalled as done before it's transmitted.
-	 * @return The new processing delay. If zero, the packet should be sent.
-	 */
-	int decrementProcessingDelay() {
-		return processingDelay.decrementAndGet();
-	}
-	
-	/**
-	 * Retrieve the number of times a packet must be signalled to be done before it's sent.
-	 * @return Number of processing delays.
-	 */
-	public int getProcessingDelay() {
-		return processingDelay.get();
-	}
-	
-	/**
-	 * Whether or not this packet is or has been queued for processing.
-	 * @return TRUE if it has, FALSE otherwise.
-	 */
-	public boolean isQueued() {
-		return queuedSendingIndex != null;
-	}
-
-	/**
-	 * Retrieve the sending index when the packet was queued.
-	 * @return Queued sending index.
-	 */
-	public long getQueuedSendingIndex() {
-		return queuedSendingIndex != null ? queuedSendingIndex : 0;
-	}
-
-	/**
-	 * Set the sending index when the packet was queued.
-	 * @param queuedSendingIndex - sending index.
-	 */
-	void setQueuedSendingIndex(Long queuedSendingIndex) {
-		this.queuedSendingIndex = queuedSendingIndex;
-	}
-
-	/**
-	 * Processing lock used to synchronize access to the parent PacketEvent and PacketContainer.
-	 * <p>
-	 * This lock is automatically acquired for every asynchronous packet listener. It should only be
-	 * used to synchronize access to a PacketEvent if it's processing has been delayed.
-	 * @return A processing lock.
-	 */
-	public Object getProcessingLock() {
-		return processingLock;
-	}
-
-	public void setProcessingLock(Object processingLock) {
-		this.processingLock = processingLock;
-	}
-
-	/**
-	 * Retrieve whether or not this packet has already been sent.
-	 * @return TRUE if it has been sent before, FALSE otherwise.
-	 */
-	public boolean isTransmitted() {
-		return transmitted;
-	}
-
-	/**
-	 * Determine if this packet has expired.
-	 * @return TRUE if it has, FALSE otherwise.
-	 */
-	public boolean hasExpired() {
-		return hasExpired(System.currentTimeMillis());
-	}
-	
-	/**
-	 * Determine if this packet has expired given this time.
-	 * @param currentTime - the current time in milliseconds since 01.01.1970 00:00.
-	 * @return TRUE if it has, FALSE otherwise.
-	 */
-	public boolean hasExpired(long currentTime) {
-		return timeout < currentTime;
-	}
-	
-	/**
-	 * Determine if the asynchronous handling should be cancelled.
-	 * @return TRUE if it should, FALSE otherwise.
-	 */
-	public boolean isAsyncCancelled() {
-		return asyncCancelled;
-	}
-
-	/**
-	 * Set whether or not the asynchronous handling should be cancelled.
-	 * <p>
-	 * This is only relevant during the synchronous processing. Asynchronous
-	 * listeners should use the normal cancel-field to cancel a PacketEvent.
-	 * 
-	 * @param asyncCancelled - TRUE to cancel it, FALSE otherwise.
-	 */
-	public void setAsyncCancelled(boolean asyncCancelled) {
-		this.asyncCancelled = asyncCancelled;
-	}
-
-	/**
-	 * Retrieve the current asynchronous listener handler.
-	 * @return Asychronous listener handler, or NULL if this packet is not asynchronous.
-	 */
-	public AsyncListenerHandler getListenerHandler() {
-		return listenerHandler;
-	}
-
-	/**
-	 * Set the current asynchronous listener handler.
-	 * <p>
-	 * Used by the worker to update the value.
-	 * @param listenerHandler - new listener handler.
-	 */
-	void setListenerHandler(AsyncListenerHandler listenerHandler) {
-		this.listenerHandler = listenerHandler;
-	}
-
-	/**
-	 * Retrieve the current worker ID.
-	 * @return Current worker ID.
-	 */
-	public int getWorkerID() {
-		return workerID;
-	}
-
-	/**
-	 * Set the current worker ID.
-	 * <p>
-	 * Used by the worker.
-	 * @param workerID - new worker ID.
-	 */
-	void setWorkerID(int workerID) {
-		this.workerID = workerID;
-	}
-
-	/**
-	 * Retrieve iterator for the next listener in line.
-	 * @return Next async packet listener iterator.
-	 */
-	Iterator<PrioritizedListener<AsyncListenerHandler>> getListenerTraversal() {
-		return listenerTraversal;
-	}
-	
-	/**
-	 * Set the iterator for the next listener.
-	 * @param listenerTraversal - the new async packet listener iterator.
-	 */
-	void setListenerTraversal(Iterator<PrioritizedListener<AsyncListenerHandler>> listenerTraversal) {
-		this.listenerTraversal = listenerTraversal;
-	}
-	
-	/**
-	 * Transmit a given packet to the current packet stream.
-	 * @param event - the packet to send.
-	 * @throws IOException If the packet couldn't be sent.
-	 */
-	void sendPacket(PacketEvent event) throws IOException {
-		try {
-			if (event.isServerPacket()) {
-				packetStream.sendServerPacket(event.getPlayer(), event.getPacket(), NetworkMarker.getNetworkMarker(event), false);
-			} else {
-				packetStream.recieveClientPacket(event.getPlayer(), event.getPacket(), NetworkMarker.getNetworkMarker(event), false);
-			}
-			transmitted = true;
-			
-		} catch (InvocationTargetException e) {
-			throw new IOException("Cannot send packet", e);
-		} catch (IllegalAccessException e) {
-			throw new IOException("Cannot send packet", e);
-		}
-	}
-	
-	/**
-	 * Determine if Minecraft allows asynchronous processing of this packet.
-	 * @param event - packet event
-	 * @return TRUE if it does, FALSE otherwise.
-	 * @throws FieldAccessException If determining fails for some reasaon
-	 */
-	public boolean isMinecraftAsync(PacketEvent event) throws FieldAccessException {
-		if (isMinecraftAsync == null && !alwaysSync) {
-			try {
-				isMinecraftAsync = FuzzyReflection.fromClass(MinecraftReflection.getPacketClass()).getMethodByName("a_.*");
-			} catch (RuntimeException e) {
-				// This will occur in 1.2.5 (or possibly in later versions)
-				List<Method> methods = FuzzyReflection.fromClass(MinecraftReflection.getPacketClass()).
-										getMethodListByParameters(boolean.class, new Class[] {});
-				
-				// Try to look for boolean methods
-				if (methods.size() == 2) {
-					isMinecraftAsync = methods.get(1);
-				} else if (methods.size() == 1) {
-					// We're in 1.2.5
-					alwaysSync = true;
-				} else if (MinecraftVersion.getCurrentVersion().isAtLeast(MinecraftVersion.BOUNTIFUL_UPDATE)) {
-					// The centralized async marker was removed in 1.8
-					// Incoming chat packets can be async
-					if (event.getPacketType() == PacketType.Play.Client.CHAT) {
-						String content = event.getPacket().getStrings().readSafely(0);
-						if (content != null) {
-							// Incoming chat packets are async only if they aren't commands
-							return ! content.startsWith("/");
-						} else {
-							ProtocolLogger.log(Level.WARNING, "Failed to determine contents of incoming chat packet!");
-							alwaysSync = true;
-						}
-					} else if (event.getPacketType() == PacketType.Status.Server.SERVER_INFO) {
-						return true;
-					} else {
-						// TODO: Find more cases of async packets
-						return false;
-					}
-				} else {
-					ProtocolLogger.log(Level.INFO, "Could not determine asynchronous state of packets (this can probably be ignored)");
-					alwaysSync = true;
-				}
-			}
-		}
-
-		if (alwaysSync) {
-			return false;
-		} else {
-			try {
-				// Wrap exceptions
-				return (Boolean) isMinecraftAsync.invoke(event.getPacket().getHandle());
-			} catch (IllegalArgumentException e) {
-				throw new FieldAccessException("Illegal argument", e);
-			} catch (IllegalAccessException e) {
-				throw new FieldAccessException("Unable to reflect method call 'a_', or: isAsyncPacket.", e);
-			} catch (InvocationTargetException e) {
-				throw new FieldAccessException("Minecraft error", e);
-			}
-		}
-	}
-	
-	@Override
-	public int compareTo(AsyncMarker o) {
-		if (o == null)
-			return 1;
-		else
-			return Longs.compare(getNewSendingIndex(), o.getNewSendingIndex());
-	}
-	
-	@Override
-	public boolean equals(Object other) {
-		// Standard equals
-		if (other == this)
-			return true;
-		if (other instanceof AsyncMarker)
-			return getNewSendingIndex() == ((AsyncMarker) other).getNewSendingIndex();
-		else
-			return false;
-	}
-	
-	@Override
-	public int hashCode() {
-		return Longs.hashCode(getNewSendingIndex());
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/async/NullPacketListener.java

@@ -1,81 +0,0 @@
-/*
- *  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.async;
-
-import org.bukkit.plugin.Plugin;
-
-import com.comphenix.protocol.events.ListenerOptions;
-import com.comphenix.protocol.events.ListenerPriority;
-import com.comphenix.protocol.events.ListeningWhitelist;
-import com.comphenix.protocol.events.PacketEvent;
-import com.comphenix.protocol.events.PacketListener;
-
-/**
- * Represents a NO OPERATION listener.
- * 
- * @author Kristian
- */
-class NullPacketListener implements PacketListener {
-	
-	private ListeningWhitelist sendingWhitelist;
-	private ListeningWhitelist receivingWhitelist;
-	private Plugin plugin;
-
-	/**
-	 * Create a no-op listener with the same whitelist and plugin as the given listener.
-	 * @param original - the packet listener to copy.
-	 */
-	public NullPacketListener(PacketListener original) {
-		this.sendingWhitelist = cloneWhitelist(ListenerPriority.LOW, original.getSendingWhitelist());
-		this.receivingWhitelist = cloneWhitelist(ListenerPriority.LOW, original.getReceivingWhitelist());
-		this.plugin = original.getPlugin();
-	}
-
-	@Override
-	public void onPacketSending(PacketEvent event) {
-		// NULL
-	}
-
-	@Override
-	public void onPacketReceiving(PacketEvent event) {
-		// NULL
-	}
-
-	@Override
-	public ListeningWhitelist getSendingWhitelist() {
-		return sendingWhitelist;
-	}
-
-	@Override
-	public ListeningWhitelist getReceivingWhitelist() {
-		return receivingWhitelist;
-	}
-	
-	private ListeningWhitelist cloneWhitelist(ListenerPriority priority, ListeningWhitelist whitelist) {
-		if (whitelist != null) 
-			// We don't use the Bukkit API, so don't engage the ProtocolLib synchronization code
-			return ListeningWhitelist.newBuilder(whitelist).priority(priority).mergeOptions(ListenerOptions.ASYNC).build();
-		else 
-			return null;
-	}
-
-	@Override
-	public Plugin getPlugin() {
-		return plugin;
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/async/PacketProcessingQueue.java

@@ -1,196 +0,0 @@
-/*
- *  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.async;
-
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.PriorityQueue;
-import java.util.Queue;
-import java.util.concurrent.Semaphore;
-
-import com.comphenix.protocol.ProtocolLibrary;
-import com.comphenix.protocol.concurrency.AbstractConcurrentListenerMultimap;
-import com.comphenix.protocol.error.Report;
-import com.comphenix.protocol.error.ReportType;
-import com.comphenix.protocol.events.PacketEvent;
-import com.comphenix.protocol.injector.PrioritizedListener;
-import com.google.common.collect.MinMaxPriorityQueue;
-
-
-/**
- * Handles the processing of every packet type.
- * 
- * @author Kristian
- */
-class PacketProcessingQueue extends AbstractConcurrentListenerMultimap<AsyncListenerHandler> {
-	public static final ReportType REPORT_GUAVA_CORRUPT_MISSING = 
-			new ReportType("Guava is either missing or corrupt. Reverting to PriorityQueue.");
-
-	// Initial number of elements
-	public static final int INITIAL_CAPACITY = 64;
-	
-	/**
-	 * Default maximum number of packets to process concurrently.
-	 */
-	public static final int DEFAULT_MAXIMUM_CONCURRENCY = 32;
-	
-	/**
-	 * Default maximum number of packets to queue for processing.
-	 */
-	public static final int DEFAULT_QUEUE_LIMIT = 1024 * 60;
-	
-	/**
-	 * Number of packets we're processing concurrently.
-	 */
-	private final int maximumConcurrency;
-	private Semaphore concurrentProcessing;
-	
-	// Queued packets for being processed
-	private Queue<PacketEventHolder> processingQueue;
-	
-	// Packets for sending
-	private PlayerSendingHandler sendingHandler;
-	
-	public PacketProcessingQueue(PlayerSendingHandler sendingHandler) {
-		this(sendingHandler, INITIAL_CAPACITY, DEFAULT_QUEUE_LIMIT, DEFAULT_MAXIMUM_CONCURRENCY);
-	}
-	
-	public PacketProcessingQueue(PlayerSendingHandler sendingHandler, int initialSize, int maximumSize, int maximumConcurrency) {
-		super();
-
-		try {
-			this.processingQueue = Synchronization.queue(MinMaxPriorityQueue.
-					expectedSize(initialSize).
-					maximumSize(maximumSize).
-					<PacketEventHolder>create(), null);
-		} catch (IncompatibleClassChangeError e) {
-			// Print in the console
-			ProtocolLibrary.getErrorReporter().reportWarning(
-				this, Report.newBuilder(REPORT_GUAVA_CORRUPT_MISSING).error(e));
-			
-			// It's a Beta class after all
-			this.processingQueue = Synchronization.queue(
-					new PriorityQueue<PacketEventHolder>(), null);
-		}
-				
-		this.maximumConcurrency = maximumConcurrency;
-		this.concurrentProcessing = new Semaphore(maximumConcurrency);
-		this.sendingHandler = sendingHandler;
-	}
-	
-	/**
-	 * Enqueue a packet for processing by the asynchronous listeners.
-	 * @param packet - packet to process.
-	 * @param onMainThread - whether or not this is occuring on the main thread.
-	 * @return TRUE if we sucessfully queued the packet, FALSE if the queue ran out if space.
-	 */
-	public boolean enqueue(PacketEvent packet, boolean onMainThread) {
-		try {
-			processingQueue.add(new PacketEventHolder(packet));
-
-			// Begin processing packets
-			signalBeginProcessing(onMainThread);
-			return true;
-		} catch (IllegalStateException e) {
-			return false;
-		}
-	}
-	
-	/**
-	 * Number of packet events in the queue.
-	 * @return The number of packet events in the queue.
-	 */
-	public int size() {
-		return processingQueue.size();
-	}
-	
-	/**
-	 * Called by the current method and each thread to signal that a packet might be ready for processing.
-	 * @param onMainThread - whether or not this is occuring on the main thread.
-	 */
-	public void signalBeginProcessing(boolean onMainThread) {	
-		while (concurrentProcessing.tryAcquire()) {
-			PacketEventHolder holder = processingQueue.poll();
-			
-			// Any packet queued?
-			if (holder != null) {
-				PacketEvent packet = holder.getEvent();
-				AsyncMarker marker = packet.getAsyncMarker();
-				Collection<PrioritizedListener<AsyncListenerHandler>> list = getListener(packet.getPacketType());
-				
-				marker.incrementProcessingDelay();
-				
-				// Yes, removing the marker will cause the chain to stop
-				if (list != null) {
-					Iterator<PrioritizedListener<AsyncListenerHandler>> iterator = list.iterator();
-					
-					if (iterator.hasNext()) {
-						marker.setListenerTraversal(iterator);
-						iterator.next().getListener().enqueuePacket(packet);
-						continue;
-					}
-				}
-				
-				// The packet has no further listeners. Just send it.
-				if (marker.decrementProcessingDelay() == 0) {
-					PacketSendingQueue sendingQueue = sendingHandler.getSendingQueue(packet, false);
-					
-					// In case the player has logged out
-					if (sendingQueue != null)
-						sendingQueue.signalPacketUpdate(packet, onMainThread);
-				}
-				signalProcessingDone();
-				
-			} else {
-				// No more queued packets.
-				signalProcessingDone();
-				return;
-			}
- 		}
-	}
-	
-	/**
-	 * Called when a packet has been processed.
-	 */
-	public void signalProcessingDone() {
-		concurrentProcessing.release();
-	}
-
-	/**
-	 * Retrieve the maximum number of packets to process at any given time.
-	 * @return Number of simultaneous packet to process.
-	 */
-	public int getMaximumConcurrency() {
-		return maximumConcurrency;
-	}
-	
-	public void cleanupAll() {
-		// Cancel all the threads and every listener
-		for (PrioritizedListener<AsyncListenerHandler> handler : values()) {
-			if (handler != null) {
-				handler.getListener().cancel();
-			}
-		}
-		
-		// Remove the rest, just in case
-		clearListeners();
-		
-		// Remove every packet in the queue
-		processingQueue.clear();
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/async/PacketSendingQueue.java

@@ -1,307 +0,0 @@
-/*
- *  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.async;
-
-import java.io.IOException;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.concurrent.Executor;
-import java.util.concurrent.PriorityBlockingQueue;
-
-import org.bukkit.entity.Player;
-
-import com.comphenix.protocol.PacketType;
-import com.comphenix.protocol.ProtocolLibrary;
-import com.comphenix.protocol.error.Report;
-import com.comphenix.protocol.error.ReportType;
-import com.comphenix.protocol.events.PacketEvent;
-import com.comphenix.protocol.injector.PlayerLoggedOutException;
-import com.comphenix.protocol.reflect.FieldAccessException;
-
-/**
- * Represents packets ready to be transmitted to a client.
- * @author Kristian
- */
-abstract class PacketSendingQueue {
-	public static final ReportType REPORT_DROPPED_PACKET = new ReportType("Warning: Dropped packet index %s of type %s.");
-	
-	public static final int INITIAL_CAPACITY = 10;
-	
-	private PriorityBlockingQueue<PacketEventHolder> sendingQueue;
-	
-	// Asynchronous packet sending
-	private Executor asynchronousSender;
-	// Whether or not packet transmission must occur on a specific thread
-	private final boolean notThreadSafe;
-	// Whether or not we've run the cleanup procedure
-	private boolean cleanedUp = false;
-	
-	/**
-	 * Create a packet sending queue.
-	 * @param notThreadSafe - whether or not to synchronize with the main thread or a background thread.
-	 */
-	public PacketSendingQueue(boolean notThreadSafe, Executor asynchronousSender) {
-		this.sendingQueue = new PriorityBlockingQueue<PacketEventHolder>(INITIAL_CAPACITY);
-		this.notThreadSafe = notThreadSafe;
-		this.asynchronousSender = asynchronousSender;
-	}
-	
-	/**
-	 * Number of packet events in the queue.
-	 * @return The number of packet events in the queue.
-	 */
-	public int size() {
-		return sendingQueue.size();
-	}
-	
-	/**
-	 * Enqueue a packet for sending. 
-	 * @param packet - packet to queue.
-	 */
-	public void enqueue(PacketEvent packet) {
-		sendingQueue.add(new PacketEventHolder(packet));
-	}
-	
-	/**
-	 * Invoked when one of the packets have finished processing.
-	 * @param packetUpdated - the packet that has now been updated.
-	 * @param onMainThread - whether or not this is occuring on the main thread.
-	 */
-	public synchronized void signalPacketUpdate(PacketEvent packetUpdated, boolean onMainThread) {
-		
-		AsyncMarker marker = packetUpdated.getAsyncMarker();
-		
-		// Should we reorder the event?
-		if (marker.getQueuedSendingIndex() != marker.getNewSendingIndex() && !marker.hasExpired()) {
-			PacketEvent copy = PacketEvent.fromSynchronous(packetUpdated, marker);
-			
-			// "Cancel" the original event
-			packetUpdated.setReadOnly(false);
-			packetUpdated.setCancelled(true);
-			
-			// Enqueue the copy with the new sending index
-			enqueue(copy);
-		}
-		
-		// Mark this packet as finished
-		marker.setProcessed(true);
-		trySendPackets(onMainThread);
-	}
-
-	/***
-	 * Invoked when a list of packet IDs are no longer associated with any listeners.
-	 * @param packetsRemoved - packets that no longer have any listeners.
-	 * @param onMainThread - whether or not this is occuring on the main thread.
-	 */
-	public synchronized void signalPacketUpdate(List<PacketType> packetsRemoved, boolean onMainThread) {
-		Set<PacketType> lookup = new HashSet<PacketType>(packetsRemoved);
-		
-		// Note that this is O(n), so it might be expensive
-		for (PacketEventHolder holder : sendingQueue) {
-			PacketEvent event = holder.getEvent();
-			
-			if (lookup.contains(event.getPacketType())) {
-				event.getAsyncMarker().setProcessed(true);
-			}
-		}
-		
-		// This is likely to have changed the situation a bit
-		trySendPackets(onMainThread);
-	}
-	
-	/**
-	 * Attempt to send any remaining packets.
-	 * @param onMainThread - whether or not this is occuring on the main thread.
-	 */
-	public void trySendPackets(boolean onMainThread) {
-		// Whether or not to continue sending packets
-		boolean sending = true;
-		
-		// Transmit as many packets as we can
-		while (sending) {
-			PacketEventHolder holder = sendingQueue.poll();
-			
-			if (holder != null) {
-				sending = processPacketHolder(onMainThread, holder);
-					
-				if (!sending) {
-					// Add it back again
-					sendingQueue.add(holder);
-				}
-				
-			} else {
-				// No more packets to send
-				sending = false;
-			}
-		}
-	}
-	
-	/**
-	 * Invoked when a packet might be ready for transmission.
-	 * @param onMainThread - TRUE if we're on the main thread, FALSE otherwise.
-	 * @param holder - packet container.
-	 * @return TRUE to continue sending packets, FALSE otherwise.
-	 */
-	private boolean processPacketHolder(boolean onMainThread, final PacketEventHolder holder) {
-		PacketEvent current = holder.getEvent();
-		AsyncMarker marker = current.getAsyncMarker();
-		boolean hasExpired = marker.hasExpired();
-		
-		// Guard in cause the queue is closed
-		if (cleanedUp) {
-			return true;
-		}
-				
-		// End condition?
-		if (marker.isProcessed() || hasExpired) {
-			if (hasExpired) {
-				// Notify timeout listeners
-				onPacketTimeout(current);
-				
-				// Recompute
-				marker = current.getAsyncMarker();
-				hasExpired = marker.hasExpired();
-				
-				// Could happen due to the timeout listeners
-				if (!marker.isProcessed() && !hasExpired) {
-					return false;
-				}
-			}
-			
-			// Is it okay to send the packet?
-			if (!current.isCancelled() && !hasExpired) {
-				// Make sure we're on the main thread
-				if (notThreadSafe) {
-					try {
-						boolean wantAsync = marker.isMinecraftAsync(current);
-						boolean wantSync = !wantAsync;
-						
-						// Wait for the next main thread heartbeat if we haven't fulfilled our promise
-						if (!onMainThread && wantSync) {
-							return false;
-						}
-						
-						// Let's give it what it wants
-						if (onMainThread && wantAsync) {
-							asynchronousSender.execute(new Runnable() {
-								@Override
-								public void run() {
-									// We know this isn't on the main thread
-									processPacketHolder(false, holder);
-								}
-							});
-							
-							// Scheduler will do the rest
-							return true;
-						}
-						
-					} catch (FieldAccessException e) {
-						e.printStackTrace();
-						
-						// Just drop the packet
-						return true;
-					}
-				} 
-				
-				// Silently skip players that have logged out
-				if (isOnline(current.getPlayer())) {
-					sendPacket(current);
-				}
-			} 
-			
-			// Drop the packet
-			return true;
-		}
-		
-		// Add it back and stop sending
-		return false;
-	}
-	
-	/**
-	 * Invoked when a packet has timed out.
-	 * @param event - the timed out packet.
-	 */
-	protected abstract void onPacketTimeout(PacketEvent event);
-	
-	private boolean isOnline(Player player) {
-		return player != null && player.isOnline();
-	}
-	
-	/**
-	 * Send every packet, regardless of the processing state.
-	 */
-	private void forceSend() {
-		while (true) {
-			PacketEventHolder holder = sendingQueue.poll();
-			
-			if (holder != null) {
-				sendPacket(holder.getEvent());
-			} else {
-				break;
-			}
-		}
-	}
-	
-	/**
-	 * Whether or not the packet transmission must synchronize with the main thread.
-	 * @return TRUE if it must, FALSE otherwise.
-	 */
-	public boolean isSynchronizeMain() {
-		return notThreadSafe;
-	}
-
-	/**
-	 * Transmit a packet, if it hasn't already.
-	 * @param event - the packet to transmit.
-	 */
-	private void sendPacket(PacketEvent event) {
-		
-		AsyncMarker marker = event.getAsyncMarker();
-		
-		try {
-			// Don't send a packet twice
-			if (marker != null && !marker.isTransmitted()) {
-				marker.sendPacket(event);
-			}
-		
-		} catch (PlayerLoggedOutException e) {
-			ProtocolLibrary.getErrorReporter().reportDebug(this, Report.newBuilder(REPORT_DROPPED_PACKET).
-				messageParam(marker.getOriginalSendingIndex(), event.getPacketType()).
-				callerParam(event)
-			);
-			
-		} catch (IOException e) {
-			// Just print the error
-			e.printStackTrace();
-		}
-	}
-
-	/**
-	 * Automatically transmits every delayed packet.
-	 */
-	public void cleanupAll() {
-		if (!cleanedUp) {
-			// Note that the cleanup itself will always occur on the main thread
-			forceSend();
-			
-			// And we're done
-			cleanedUp = true;
-		}
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/async/PlayerSendingHandler.java

@@ -1,264 +0,0 @@
-/*
- *  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.async;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.ConcurrentMap;
-import java.util.concurrent.Executor;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ThreadFactory;
-
-import org.bukkit.entity.Player;
-
-import com.comphenix.protocol.PacketType;
-import com.comphenix.protocol.concurrency.ConcurrentPlayerMap;
-import com.comphenix.protocol.error.ErrorReporter;
-import com.comphenix.protocol.events.PacketEvent;
-import com.comphenix.protocol.injector.SortedPacketListenerList;
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
-
-/**
- * Contains every sending queue for every player.
- * 
- * @author Kristian
- */
-class PlayerSendingHandler {
-	private ErrorReporter reporter;
-	private ConcurrentMap<Player, QueueContainer> playerSendingQueues;
-	
-	// Timeout listeners
-	private SortedPacketListenerList serverTimeoutListeners;
-	private SortedPacketListenerList clientTimeoutListeners;
-	
-	// Asynchronous packet sending
-	private Executor asynchronousSender;
-	
-	// Whether or not we're currently cleaning up
-	private volatile boolean cleaningUp;
-	
-	/**
-	 * Sending queues for a given player.
-	 * 
-	 * @author Kristian
-	 */
-	private class QueueContainer {
-		private PacketSendingQueue serverQueue;
-		private PacketSendingQueue clientQueue;
-		
-		public QueueContainer() {
-			// Server packets can be sent concurrently
-			serverQueue = new PacketSendingQueue(false, asynchronousSender) {
-				@Override
-				protected void onPacketTimeout(PacketEvent event) {
-					if (!cleaningUp) {
-						serverTimeoutListeners.invokePacketSending(reporter, event);
-					}
-				}
-			};
-			
-			// Client packets must be synchronized
-			clientQueue = new PacketSendingQueue(true, asynchronousSender) {
-				@Override
-				protected void onPacketTimeout(PacketEvent event) {
-					if (!cleaningUp) {
-						clientTimeoutListeners.invokePacketSending(reporter, event);
-					}
-				}
-			};
-		}
-
-		public PacketSendingQueue getServerQueue() {
-			return serverQueue;
-		}
-
-		public PacketSendingQueue getClientQueue() {
-			return clientQueue;
-		}
-	}
-	
-	/**
-	 * Initialize a packet sending handler.
-	 * @param reporter - error reporter.
-	 * @param serverTimeoutListeners - set of server timeout listeners.
-	 * @param clientTimeoutListeners - set of client timeout listeners.
-	 */
-	public PlayerSendingHandler(ErrorReporter reporter, 
-			SortedPacketListenerList serverTimeoutListeners, SortedPacketListenerList clientTimeoutListeners) {
-		
-		this.reporter = reporter;
-		this.serverTimeoutListeners = serverTimeoutListeners;
-		this.clientTimeoutListeners = clientTimeoutListeners;
-		
-		// Initialize storage of queues
-		this.playerSendingQueues = ConcurrentPlayerMap.usingAddress();
-	}
-	
-	/**
-	 * Start the asynchronous packet sender.
-	 */
-	public synchronized void initializeScheduler() {
-		if (asynchronousSender == null) {
-			ThreadFactory factory = new ThreadFactoryBuilder().
-				setDaemon(true).
-				setNameFormat("ProtocolLib-AsyncSender %s").
-				build();
-			asynchronousSender = Executors.newSingleThreadExecutor(factory);
-		}
-	}
-
-	/**
-	 * Retrieve the sending queue this packet belongs to.
-	 * @param packet - the packet.
-	 * @return The server or client sending queue the packet belongs to.
-	 */
-	public PacketSendingQueue getSendingQueue(PacketEvent packet) {
-		return getSendingQueue(packet, true);
-	}
-	
-	/**
-	 * Retrieve the sending queue this packet belongs to.
-	 * @param packet - the packet.
-	 * @param createNew - if TRUE, create a new queue if it hasn't already been created.
-	 * @return The server or client sending queue the packet belongs to.
-	 */
-	public PacketSendingQueue getSendingQueue(PacketEvent packet, boolean createNew) {
-		QueueContainer queues = playerSendingQueues.get(packet.getPlayer());
-		
-		// Safe concurrent initialization
-		if (queues == null && createNew) {
-			final QueueContainer newContainer = new QueueContainer();
-
-			// Attempt to map the queue
-			queues = playerSendingQueues.putIfAbsent(packet.getPlayer(), newContainer);
-			
-			if (queues == null) {
-				queues = newContainer;
-			}
-		}
-		
-		// Check for NULL again
-		if (queues != null)
-			return packet.isServerPacket() ? queues.getServerQueue() : queues.getClientQueue();
-		else
-			return null;
-	}
-
-	/**
-	 * Send all pending packets.
-	 */
-	public void sendAllPackets() {
-		if (!cleaningUp) {
-			for (QueueContainer queues : playerSendingQueues.values()) {
-				queues.getClientQueue().cleanupAll();
-				queues.getServerQueue().cleanupAll();
-			}
-		}
-	}
-	
-	/**
-	 * Immediately send every server packet with the given list of IDs.
-	 * @param types - types of every packet to send immediately.
-	 * @param synchronusOK - whether or not we're running on the main thread. 
-	 */
-	public void sendServerPackets(List<PacketType> types, boolean synchronusOK) {
-		if (!cleaningUp) {
-			for (QueueContainer queue : playerSendingQueues.values()) {
-				queue.getServerQueue().signalPacketUpdate(types, synchronusOK);
-			}
-		}
-	}
-	
-	/**
-	 * Immediately send every client packet with the given list of IDs.
-	 * @param ids - ID of every packet to send immediately.
-	 * @param synchronusOK - whether or not we're running on the main thread. 
-	 */
-	public void sendClientPackets(List<PacketType> types, boolean synchronusOK) {
-		if (!cleaningUp) {
-			for (QueueContainer queue : playerSendingQueues.values()) {
-				queue.getClientQueue().signalPacketUpdate(types, synchronusOK);
-			}
-		}
-	}
-	
-	/**
-	 * Send any outstanding server packets.
-	 * @param onMainThread - whether or not this is occuring on the main thread.
-	 */
-	public void trySendServerPackets(boolean onMainThread) {
-		for (QueueContainer queue : playerSendingQueues.values()) {
-			queue.getServerQueue().trySendPackets(onMainThread);
-		}
-	}
-	
-	/**
-	 * Send any outstanding server packets.
-	 * @param onMainThread - whether or not this is occuring on the main thread.
-	 */
-	public void trySendClientPackets(boolean onMainThread) {
-		for (QueueContainer queue : playerSendingQueues.values()) {
-			queue.getClientQueue().trySendPackets(onMainThread);
-		}
-	}
-	
-	/**
-	 * Retrieve every server packet queue for every player.
-	 * @return Every sever packet queue.
-	 */
-	public List<PacketSendingQueue> getServerQueues() {
-		List<PacketSendingQueue> result = new ArrayList<PacketSendingQueue>();
-		
-		for (QueueContainer queue : playerSendingQueues.values())
-			result.add(queue.getServerQueue());
-		return result;
-	}
-	
-	/**
-	 * Retrieve every client packet queue for every player.
-	 * @return Every client packet queue.
-	 */
-	public List<PacketSendingQueue> getClientQueues() {
-		List<PacketSendingQueue> result = new ArrayList<PacketSendingQueue>();
-		
-		for (QueueContainer queue : playerSendingQueues.values())
-			result.add(queue.getClientQueue());
-		return result;
-	}
-	
-	/**
-	 * Send all pending packets and clean up queues.
-	 */
-	public void cleanupAll() {
-		if (!cleaningUp) {
-			cleaningUp = true;
-			
-			sendAllPackets();
-			playerSendingQueues.clear();
-		}
-	}
-
-	/**
-	 * Invoked when a player has just logged out.
-	 * @param player - the player that just logged out.
-	 */
-	public void removePlayer(Player player) {
-		// Every packet will be dropped - there's nothing we can do
-		playerSendingQueues.remove(player);
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/async/Synchronization.java

@@ -1,228 +0,0 @@
-/*
- *  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.async;
-
-import java.io.Serializable;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.Queue;
-
-import javax.annotation.Nullable;
-
-import com.google.common.base.Preconditions;
-
-/**
- * Synchronization views copied from Google Guava.
- * 
- * @author Kristian
- */
-class Synchronization {
-
-	/**
-	 * Create a synchronized wrapper for the given queue.
-	 * <p>
-	 * This wrapper cannot synchronize the iterator(). Callers are expected 
-	 * to synchronize iterators manually.
-	 * @param queue - the queue to synchronize.
-	 * @param mutex - synchronization mutex, or NULL to use the queue.
-	 * @return A synchronization wrapper.
-	 */
-	public static <E> Queue<E> queue(Queue<E> queue, @Nullable Object mutex) {
-		return (queue instanceof SynchronizedQueue) ? 
-				queue : 
-					new SynchronizedQueue<E>(queue, mutex);
-	}
-	
-	private static class SynchronizedObject implements Serializable {
-		private static final long serialVersionUID = -4408866092364554628L;
-
-		final Object delegate;
-		final Object mutex;
-
-		SynchronizedObject(Object delegate, @Nullable Object mutex) {
-			this.delegate = Preconditions.checkNotNull(delegate);
-			this.mutex = (mutex == null) ? this : mutex;
-		}
-
-		Object delegate() {
-			return delegate;
-		}
-
-		// No equals and hashCode; see ForwardingObject for details.
-
-		@Override
-		public String toString() {
-			synchronized (mutex) {
-				return delegate.toString();
-			}
-		}
-	}
-
-	private static class SynchronizedCollection<E> extends SynchronizedObject implements Collection<E> {
-		private static final long serialVersionUID = 5440572373531285692L;
-
-		private SynchronizedCollection(Collection<E> delegate,
-				@Nullable Object mutex) {
-			super(delegate, mutex);
-		}
-
-		@SuppressWarnings("unchecked")
-		@Override
-		Collection<E> delegate() {
-			return (Collection<E>) super.delegate();
-		}
-
-		@Override
-		public boolean add(E e) {
-			synchronized (mutex) {
-				return delegate().add(e);
-			}
-		}
-
-		@Override
-		public boolean addAll(Collection<? extends E> c) {
-			synchronized (mutex) {
-				return delegate().addAll(c);
-			}
-		}
-
-		@Override
-		public void clear() {
-			synchronized (mutex) {
-				delegate().clear();
-			}
-		}
-
-		@Override
-		public boolean contains(Object o) {
-			synchronized (mutex) {
-				return delegate().contains(o);
-			}
-		}
-
-		@Override
-		public boolean containsAll(Collection<?> c) {
-			synchronized (mutex) {
-				return delegate().containsAll(c);
-			}
-		}
-
-		@Override
-		public boolean isEmpty() {
-			synchronized (mutex) {
-				return delegate().isEmpty();
-			}
-		}
-
-		@Override
-		public Iterator<E> iterator() {
-			return delegate().iterator(); // manually synchronized
-		}
-
-		@Override
-		public boolean remove(Object o) {
-			synchronized (mutex) {
-				return delegate().remove(o);
-			}
-		}
-
-		@Override
-		public boolean removeAll(Collection<?> c) {
-			synchronized (mutex) {
-				return delegate().removeAll(c);
-			}
-		}
-
-		@Override
-		public boolean retainAll(Collection<?> c) {
-			synchronized (mutex) {
-				return delegate().retainAll(c);
-			}
-		}
-
-		@Override
-		public int size() {
-			synchronized (mutex) {
-				return delegate().size();
-			}
-		}
-
-		@Override
-		public Object[] toArray() {
-			synchronized (mutex) {
-				return delegate().toArray();
-			}
-		}
-
-		@Override
-		public <T> T[] toArray(T[] a) {
-			synchronized (mutex) {
-				return delegate().toArray(a);
-			}
-		}
-
-	}
-
-	private static class SynchronizedQueue<E> extends SynchronizedCollection<E> implements Queue<E> {
-		private static final long serialVersionUID = 1961791630386791902L;
-
-		SynchronizedQueue(Queue<E> delegate, @Nullable Object mutex) {
-			super(delegate, mutex);
-		}
-
-		@Override
-		Queue<E> delegate() {
-			return (Queue<E>) super.delegate();
-		}
-
-		@Override
-		public E element() {
-			synchronized (mutex) {
-				return delegate().element();
-			}
-		}
-
-		@Override
-		public boolean offer(E e) {
-			synchronized (mutex) {
-				return delegate().offer(e);
-			}
-		}
-
-		@Override
-		public E peek() {
-			synchronized (mutex) {
-				return delegate().peek();
-			}
-		}
-
-		@Override
-		public E poll() {
-			synchronized (mutex) {
-				return delegate().poll();
-			}
-		}
-
-		@Override
-		public E remove() {
-			synchronized (mutex) {
-				return delegate().remove();
-			}
-		}
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/collections/ExpireHashMap.java

@@ -1,246 +0,0 @@
-package com.comphenix.protocol.collections;
-
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.PriorityQueue;
-import java.util.Set;
-import java.util.concurrent.TimeUnit;
-
-import com.google.common.base.Function;
-import com.google.common.base.Objects;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Ticker;
-import com.google.common.collect.Maps;
-import com.google.common.primitives.Longs;
-
-/**
- * Represents a hash map where each association may expire after a given time has elapsed.
- * <p>
- * Note that replaced key-value associations are only collected once the original expiration time has elapsed. 
- * 
- * @author Kristian Stangeland
- *
- * @param <K> - type of the keys.
- * @param <V> - type of the values.
- */
-public class ExpireHashMap<K, V> {
-	private class ExpireEntry implements Comparable<ExpireEntry> {
-		public final long expireTime;
-		public final K expireKey;
-		public final V expireValue;
-		
-		public ExpireEntry(long expireTime, K expireKey, V expireValue) {
-			this.expireTime = expireTime;
-			this.expireKey = expireKey;
-			this.expireValue = expireValue;
-		}
-
-		@Override
-		public int compareTo(ExpireEntry o) {
-			return Longs.compare(expireTime, o.expireTime);
-		}
-
-		@Override
-		public String toString() {
-			return "ExpireEntry [expireTime=" + expireTime + ", expireKey=" + expireKey
-					+ ", expireValue=" + expireValue + "]";
-		}
-	}
-	
-	private Map<K, ExpireEntry> keyLookup = new HashMap<K, ExpireEntry>();
-	private PriorityQueue<ExpireEntry> expireQueue =  new PriorityQueue<ExpireEntry>();
-	
-	// View of keyLookup with direct values
-	private Map<K, V> valueView = Maps.transformValues(keyLookup, new Function<ExpireEntry, V>() {
-		@Override
-		public V apply(ExpireEntry entry) {
-			return entry.expireValue;
-		}
-	});
-	
-	// Supplied by the constructor
-	private Ticker ticker;
-	
-	/**
-	 * Construct a new hash map where each entry may expire at a given time.
-	 */
-	public ExpireHashMap() {
-		this(Ticker.systemTicker());
-	}
-	
-	/**
-	 * Construct a new hash map where each entry may expire at a given time.
-	 * @param ticker - supplier of the current time.
-	 */
-	public ExpireHashMap(Ticker ticker) {
-		this.ticker = ticker;
-	}
-	
-	/**
-	 * Retrieve the value associated with the given key, if it has not expired.
-	 * @param key - the key.
-	 * @return The value, or NULL if not found or it has expired.
-	 */
-	public V get(K key) {
-		evictExpired();
-		
-		ExpireEntry entry = keyLookup.get(key);
-		return entry != null ? entry.expireValue : null;
-	}
-	
-	/**
-	 * Associate the given key with the given value, until the expire delay have elapsed.
-	 * @param key - the key.
-	 * @param value - the value.
-	 * @param expireDelay - the amount of time until this association expires. Must be greater than zero.
-	 * @param expireUnit - the unit of the expiration.
-	 * @return Any previously unexpired association with this key, or NULL.
-	 */
-	public V put(K key, V value, long expireDelay, TimeUnit expireUnit) {
-		Preconditions.checkNotNull(expireUnit, "expireUnit cannot be NULL");
-		Preconditions.checkState(expireDelay > 0, "expireDelay cannot be equal or less than zero.");
-		evictExpired();
-		
-		ExpireEntry entry = new ExpireEntry(
-			ticker.read() + TimeUnit.NANOSECONDS.convert(expireDelay, expireUnit), 
-			key, value
-		); 
-		ExpireEntry previous = keyLookup.put(key, entry);
-		
-		// We enqueue its removal
-		expireQueue.add(entry);
-		return previous != null ? previous.expireValue : null;
-	}
-	
-	/**
-	 * Determine if the given key is referring to an unexpired association in the map.
- 	 * @param key - the key.
-	 * @return TRUE if it is, FALSE otherwise.
-	 */
-	public boolean containsKey(K key) {
-		evictExpired();
-		return keyLookup.containsKey(key);
-	}
-	
-	/**
-	 * Determine if the given value is referring to an unexpired association in the map.
- 	 * @param value - the value.
-	 * @return TRUE if it is, FALSE otherwise.
-	 */
-	public boolean containsValue(V value) {
-		evictExpired();
-		
-		// Linear scan is the best we've got
-		for (ExpireEntry entry : keyLookup.values()) {
-			if (Objects.equal(value, entry.expireValue)) {
-				return true;
-			}
-		}
-		return false;
-	}
-	
-	/**
-	 * Remove a key and its associated value from the map.
-	 * @param key - the key to remove.
-	 * @return Value of the removed association, NULL otherwise.
-	 */
-	public V removeKey(K key) {
-		evictExpired();
-		
-		ExpireEntry entry = keyLookup.remove(key);
-		return entry != null ? entry.expireValue : null;
-	}
-	
-	/**
-	 * Retrieve the number of entries in the map.
-	 * @return The number of entries.
-	 */
-	public int size() {
-		evictExpired();
-		return keyLookup.size();
-	}
-	
-	/**
-	 * Retrieve a view of the keys in the current map.
-	 * @return View of the keys.
-	 */
-	public Set<K> keySet() {
-		evictExpired();
-		return keyLookup.keySet();
-	}
-	
-	/**
-	 * Retrieve a view of all the values in the current map.
-	 * @return All the values.
-	 */
-	public Collection<V> values() {
-		evictExpired();
-		return valueView.values();
-	}
-	
-	/**
-	 * Retrieve a view of all the entries in the set.
-	 * @return All the entries.
-	 */
-	public Set<Entry<K, V>> entrySet() {
-		evictExpired();
-		return valueView.entrySet();
-	}
-	
-	/**
-	 * Retrieve a view of this expire map as an ordinary map that does not support insertion.
-	 * @return The map.
-	 */
-	public Map<K, V> asMap() {
-		evictExpired();
-		return valueView;
-	}
-	
-	/**
-	 * Clear all references to key-value pairs that have been removed or replaced before they were naturally evicted.
-	 * <p>
-	 * This operation requires a linear scan of the current entries in the map.
-	 */
-	public void collect() {
-		// First evict what we can
-		evictExpired();
-		
-		// Recreate the eviction queue - this is faster than removing entries in the old queue
-		expireQueue.clear();
-		expireQueue.addAll(keyLookup.values());
-	}
-	
-	/**
-	 * Clear all the entries in the current map.
-	 */
-	public void clear() {
-		keyLookup.clear();
-		expireQueue.clear();
-	}
-	
-	/**
-	 * Evict any expired entries in the map.
-	 * <p>
-	 * This is called automatically by any of the read or write operations.
-	 */
-	protected void evictExpired() {
-		long currentTime = ticker.read();
-		
-		// Remove expired entries
-		while (expireQueue.size() > 0 && expireQueue.peek().expireTime <= currentTime) {
-			ExpireEntry entry = expireQueue.poll();
-
-			if (entry == keyLookup.get(entry.expireKey)) {
-				keyLookup.remove(entry.expireKey);
-			}
-		}
-	}
-	
-	@Override
-	public String toString() {
-		return valueView.toString();
-	}
-}
- 

modules/API/src/main/java/com/comphenix/protocol/collections/IntegerMap.java

@@ -1,140 +0,0 @@
-package com.comphenix.protocol.collections;
-
-import java.util.Arrays;
-import java.util.Map;
-
-import com.google.common.base.Preconditions;
-import com.google.common.collect.Maps;
-
-/**
- * Represents a very quick integer-based lookup map, with a fixed key space size.
- * <p>
- * Integers must be non-negative.
- * @author Kristian
- */
-public class IntegerMap<T> {
-	private T[] array;
-	private int size;
-	
-	/**
-	 * Construct a new integer map.
-	 * @param <T> Parameter type
-	 * @return A new integer map.
-	 */
-	public static <T> IntegerMap<T> newMap() {
-		return new IntegerMap<T>();
-	}
-	
-	/**
-	 * Construct a new integer map with a default capacity.
-	 */
-	public IntegerMap() {
-		this(8);
-	}
-	
-	/**
-	 * Construct a new integer map with a given capacity.
-	 * @param initialCapacity - the capacity.
-	 */
-	public IntegerMap(int initialCapacity) {
-		@SuppressWarnings("unchecked")
-		T[] backingArray = (T[]) new Object[initialCapacity];
-		this.array = backingArray;
-		this.size = 0;
-	}
-
-	/**
-	 * Associate an integer key with the given value.
-	 * @param key - the integer key. Cannot be negative.
-	 * @param value - the value. Cannot be NULL.
-	 * @return The previous association, or NULL if not found.
-	 */
-	public T put(int key, T value) {
-		ensureCapacity(key);
-		
-		T old = array[key];
-		array[key] = Preconditions.checkNotNull(value, "value cannot be NULL");
-		
-		if (old == null)
-			size++;
-		return old;
-	}
-	
-	/**
-	 * Remove an association from the map.
-	 * @param key - the key of the association to remove.
-	 * @return The old associated value, or NULL.
-	 */
-	public T remove(int key) {
-		T old = array[key];
-		array[key] = null;
-		
-		if (old != null)
-			size--;
-		return old;
-	}
-	
-	/**
-	 * Resize the backing array to fit the given key.
-	 * @param key - the key.
-	 */
-	protected void ensureCapacity(int key) {
-		int newLength = array.length;
-
-		// Don't resize if the key fits
-		if (key < 0)
-			throw new IllegalArgumentException("Negative key values are not permitted.");
-		if (key < newLength)
-			return;
-		
-		while (newLength <= key) {
-			int next = newLength * 2;
-			// Handle overflow
-			newLength = next > newLength ? next : Integer.MAX_VALUE;
-		}
-		this.array = Arrays.copyOf(array, newLength);
-	}
-	
-	/**
-	 * Retrieve the number of mappings in this map.
-	 * @return The number of mapping.
-	 */
-	public int size() {
-		return size;
-	}
-
-	/**
-	 * Retrieve the value associated with a given key.
-	 * @param key - the key.
-	 * @return The value, or NULL if not found.
-	 */
-	public T get(int key) {
-		if (key >= 0 && key < array.length)
-			return array[key];
-		return null;
-	}
-	
-	/**
-	 * Determine if the given key exists in the map.
-	 * @param key - the key to check.
-	 * @return TRUE if it does, FALSE otherwise.
-	 */
-	public boolean containsKey(int key) {
-		return get(key) != null;
-	}
-	
-	/**
-	 * Convert the current map to an Integer map.
-	 * @return The Integer map.
-	 */
-	public Map<Integer, Object> toMap() {
-		Map<Integer, Object> map = Maps.newHashMap();
-		
-		for (int i = 0; i < array.length; i++) {
-			if (array[i] != null) {
-				map.put(i, array[i]);
-			}
-		}
-		return map;
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/concurrency/AbstractConcurrentListenerMultimap.java

@@ -1,144 +0,0 @@
-/*
- *  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 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;
-
-import com.comphenix.protocol.PacketType;
-import com.comphenix.protocol.events.ListeningWhitelist;
-import com.comphenix.protocol.injector.PrioritizedListener;
-import com.google.common.collect.Iterables;
-
-/**
- * A thread-safe implementation of a listener multimap.
- * 
- * @author Kristian
- */
-public abstract class AbstractConcurrentListenerMultimap<TListener> {
-	// The core of our map
-	private ConcurrentMap<PacketType, SortedCopyOnWriteArray<PrioritizedListener<TListener>>> mapListeners;
-	
-	public AbstractConcurrentListenerMultimap() {
-		mapListeners =   new ConcurrentHashMap<PacketType, SortedCopyOnWriteArray<PrioritizedListener<TListener>>>();
-	}
-	
-	/**
-	 * 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(TListener listener, ListeningWhitelist whitelist) {
-		PrioritizedListener<TListener> prioritized = new PrioritizedListener<TListener>(listener, whitelist.getPriority());
-		
-		for (PacketType type : whitelist.getTypes()) {
-			addListener(type, prioritized);
-		}
-	}
-	
-	// Add the listener to a specific packet notifcation list
-	private void addListener(PacketType type, PrioritizedListener<TListener> listener) {
-		SortedCopyOnWriteArray<PrioritizedListener<TListener>> list = 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 preseve iterator order,
-			// which is a essential feature for our purposes.
-			final SortedCopyOnWriteArray<PrioritizedListener<TListener>> value = new SortedCopyOnWriteArray<PrioritizedListener<TListener>>();
-
-			// We may end up creating multiple multisets, but we'll agree on which to use
-			list = 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(TListener listener, ListeningWhitelist whitelist) {
-		List<PacketType> removedPackets = new ArrayList<PacketType>();
-		
-		// Again, not terribly efficient. But adding or removing listeners should be a rare event.
-		for (PacketType type : whitelist.getTypes()) {
-			SortedCopyOnWriteArray<PrioritizedListener<TListener>> list = mapListeners.get(type);
-			
-			// Remove any listeners
-			if (list != null) {
-				// Don't remove from newly created lists
-				if (list.size() > 0) {
-					// Remove this listener. Note that priority is generally ignored.
-					list.remove(new PrioritizedListener<TListener>(listener, whitelist.getPriority()));
-					
-					if (list.size() == 0) {
-						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<TListener>> getListener(PacketType type) {
-		return mapListeners.get(type);
-	}
-	
-	/**
-	 * Retrieve every listener.
-	 * @return Every listener.
-	 */
-	public Iterable<PrioritizedListener<TListener>> values() {
-		return Iterables.concat(mapListeners.values());
-	}
-	
-	/**
-	 * Retrieve every registered packet type:
-	 * @return Registered packet type.
-	 */
-	public Set<PacketType> keySet() {
-		return mapListeners.keySet();
-	}
-	
-	/**
-	 * Remove all packet listeners.
-	 */
-	protected void clearListeners() {
-		mapListeners.clear();
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/concurrency/AbstractIntervalTree.java

@@ -1,494 +0,0 @@
-/*
- *  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 java.util.HashSet;
-import java.util.Map;
-import java.util.NavigableMap;
-import java.util.Set;
-import java.util.TreeMap;
-
-import com.google.common.base.Objects;
-import com.google.common.collect.Range;
-
-/**
- * Represents a generic store of intervals and associated values. No two intervals
- * can overlap in this representation.
- * <p>
- * Note that this implementation is not thread safe.
- * 
- * @author Kristian
- *
- * @param <TKey> - type of the key. Must implement Comparable.
- * @param <TValue> - type of the value to associate.
- */
-public abstract class AbstractIntervalTree<TKey extends Comparable<TKey>, TValue> {
-	
-	protected enum State {
-		OPEN,
-		CLOSE,
-		BOTH
-	}
-	
-	/**
-	 * Represents a range and a value in this interval tree.
-	 */
-	public class Entry implements Map.Entry<Range<TKey>, TValue> {
-		private EndPoint left;
-		private EndPoint right;
-
-		Entry(EndPoint left, EndPoint right) {
-			if (left == null)
-				throw new IllegalAccessError("left cannot be NUll");
-			if (right == null)
-				throw new IllegalAccessError("right cannot be NUll");
-			if (left.key.compareTo(right.key) > 0)
-				throw new IllegalArgumentException(
-						"Left key (" + left.key + ") cannot be greater than the right key (" + right.key + ")");
-			
-			this.left = left;
-			this.right = right;
-		}
-
-		@Override
-		public Range<TKey> getKey() {
-			return Range.closed(left.key, right.key);
-		}
-
-		@Override
-		public TValue getValue() {
-			return left.value;
-		}
-
-		@Override
-		public TValue setValue(TValue value) {
-			TValue old = left.value;
-			
-			// Set both end points
-			left.value = value;
-			right.value = value;
-			return old;
-		}
-		
-		@SuppressWarnings("rawtypes")
-		@Override
-		public boolean equals(Object obj) {
-			// Quick equality check
-			if (obj == this) {
-				return true;
-			} else if (obj instanceof AbstractIntervalTree.Entry) {
-				return Objects.equal(left.key, ((AbstractIntervalTree.Entry) obj).left.key) &&
-					   Objects.equal(right.key, ((AbstractIntervalTree.Entry) obj).right.key) &&
-					   Objects.equal(left.value, ((AbstractIntervalTree.Entry) obj).left.value);
-			} else {
-				return false;
-			}
-		}
-		
-		@Override
-		public int hashCode() {
-			return Objects.hashCode(left.key, right.key, left.value);
-		}
-		
-		@Override
-		public String toString() {
-			return String.format("Value %s at [%s, %s]", left.value, left.key, right.key);
-		}
-	}
-	
-	/**
-	 * Represents a single end point (open, close or both) of a range.
-	 */
-	protected class EndPoint {
-		
-		// Whether or not the end-point is opening a range, closing a range or both.
-		public State state;
-		
-		// The value this range contains
-		public TValue value;
-		
-		// The key of this end point
-		public TKey key;
-
-		public EndPoint(State state, TKey key, TValue value) {
-			this.state = state;
-			this.key = key;
-			this.value = value;
-		}
-	}
-	
-	// To quickly look up ranges we'll index them by endpoints
-	protected NavigableMap<TKey, EndPoint> bounds = new TreeMap<TKey, EndPoint>();
-	
-	/**
-	 * Removes every interval that intersects with the given range.
-	 * @param lowerBound - lowest value to remove.
-	 * @param upperBound - highest value to remove.
-	 * @return Intervals that were removed
-	 */
-	public Set<Entry> remove(TKey lowerBound, TKey upperBound) {
-		return remove(lowerBound, upperBound, false);
-	}
-	
-	/**
-	 * Removes every interval that intersects with the given range.
-	 * @param lowerBound - lowest value to remove.
-	 * @param upperBound - highest value to remove.
-	 * @param preserveDifference - whether or not to preserve the intervals that are partially outside.
-	 * @return Intervals that were removed
-	 */
-	public Set<Entry> remove(TKey lowerBound, TKey upperBound, boolean preserveDifference) {
-		checkBounds(lowerBound, upperBound);
-		NavigableMap<TKey, EndPoint> range = bounds.subMap(lowerBound, true, upperBound, true);
-		
-		EndPoint first = getNextEndPoint(lowerBound, true);
-		EndPoint last = getPreviousEndPoint(upperBound, true);
-		
-		// Used while resizing intervals
-		EndPoint previous = null;
-		EndPoint next = null;
-		
-		Set<Entry> resized = new HashSet<Entry>();
-		Set<Entry> removed = new HashSet<Entry>();
-		
-		// Remove the previous element too. A close end-point must be preceded by an OPEN end-point.
-		if (first != null && first.state == State.CLOSE) {
-			previous = getPreviousEndPoint(first.key, false);
-			
-			// Add the interval back
-			if (previous != null) {
-				removed.add(getEntry(previous, first));
-			}
-		}
-		
-		// Get the closing element too.
-		if (last != null && last.state == State.OPEN) {
-			next = getNextEndPoint(last.key, false);
-		
-			if (next != null) {
-				removed.add(getEntry(last, next));
-			}
-		}
-		
-		// Now remove both ranges
-		removeEntrySafely(previous, first);
-		removeEntrySafely(last, next);
-		
-		// Add new resized intervals
-		if (preserveDifference) {
-			if (previous != null) {
-				resized.add(putUnsafe(previous.key, decrementKey(lowerBound), previous.value));
-			}
-			if (next != null) {
-				resized.add(putUnsafe(incrementKey(upperBound), next.key, next.value));
-			}
-		}
-		
-		// Get the removed entries too
-		getEntries(removed, range);
-		invokeEntryRemoved(removed);
-		
-		if (preserveDifference) {
-			invokeEntryAdded(resized);
-		}
-		
-		// Remove the range as well
-		range.clear();
-		return removed;
-	}
-	
-	/**
-	 * Retrieve the entry from a given set of end points.
-	 * @param left - leftmost end point.
-	 * @param right - rightmost end point.
-	 * @return The associated entry.
-	 */
-	protected Entry getEntry(EndPoint left, EndPoint right) {
-		if (left == null)
-			throw new IllegalArgumentException("left endpoint cannot be NULL.");
-		if (right == null)
-			throw new IllegalArgumentException("right endpoint cannot be NULL.");
-		
-		// Make sure the order is correct
-		if (right.key.compareTo(left.key) < 0) {
-			return getEntry(right, left);
-		} else {
-			return new Entry(left, right);
-		}
-	}
-	
-	private void removeEntrySafely(EndPoint left, EndPoint right) {
-		if (left != null && right != null) {
-			bounds.remove(left.key);
-			bounds.remove(right.key);
-		}
-	}
-	
-	// Adds a given end point
-	protected EndPoint addEndPoint(TKey key, TValue value, State state) {
-		EndPoint endPoint = bounds.get(key);
-		
-		if (endPoint != null) {
-			endPoint.state = State.BOTH;
-		} else {
-			endPoint = new EndPoint(state, key, value);
-			bounds.put(key, endPoint);
-		}
-		return endPoint;
-	}
-	
-	/**
-	 * Associates a given interval of keys with a certain value. Any previous
-	 * association will be overwritten in the given interval.
-	 * <p>
-	 * Overlapping intervals are not permitted. A key can only be associated with a single value.
-	 * 
-	 * @param lowerBound - the minimum key (inclusive).
-	 * @param upperBound - the maximum key (inclusive).
-	 * @param value - the value, or NULL to reset this range.
-	 */
-	public void put(TKey lowerBound, TKey upperBound, TValue value) {
-		// While we don't permit overlapping intervals, we'll still allow overwriting existing intervals.
-		remove(lowerBound, upperBound, true);
-		invokeEntryAdded(putUnsafe(lowerBound, upperBound, value));
-	}
-	
-	/**
-	 * Associates a given interval without performing any interval checks.
-	 * @param lowerBound - the minimum key (inclusive).
-	 * @param upperBound - the maximum key (inclusive).
-	 * @param value - the value, or NULL to reset the range.
-	 */
-	private Entry putUnsafe(TKey lowerBound, TKey upperBound, TValue value) {
-		// OK. Add the end points now
-		if (value != null) {
-			EndPoint left = addEndPoint(lowerBound, value, State.OPEN);
-			EndPoint right = addEndPoint(upperBound, value, State.CLOSE);
-
-			return new Entry(left, right);
-		} else {
-			return null;
-		}
-	}
-	
-	/**
-	 * Used to verify the validity of the given interval.
-	 * @param lowerBound - lower bound (inclusive).
-	 * @param upperBound - upper bound (inclusive).
-	 */
-	private void checkBounds(TKey lowerBound, TKey upperBound) {
-		if (lowerBound == null)
-			throw new IllegalAccessError("lowerbound cannot be NULL.");
-		if (upperBound == null)
-			throw new IllegalAccessError("upperBound cannot be NULL.");
-		if (upperBound.compareTo(lowerBound) < 0)
-			throw new IllegalArgumentException("upperBound cannot be less than lowerBound.");
-	}
-	
-	/**
-	 * Determines if the given key is within an interval.
-	 * @param key - key to check.
-	 * @return TRUE if the given key is within an interval in this tree, FALSE otherwise.
-	 */
-	public boolean containsKey(TKey key) {
-		return getEndPoint(key) != null;
-	}
-	
-	/**
-	 * Enumerates over every range in this interval tree.
-	 * @return Number of ranges.
-	 */
-	public Set<Entry> entrySet() {
-		// Don't mind the Java noise
-		Set<Entry> result = new HashSet<Entry>();
-		getEntries(result, bounds);
-		return result;
-	}
-	
-	/**
-	 * Remove every interval.
-	 */
-	public void clear() {
-		if (!bounds.isEmpty()) {
-			remove(bounds.firstKey(), bounds.lastKey());
-		}
-	}
-	
-	/**
-	 * Converts a map of end points into a set of entries.
-	 * @param destination - set of entries.
-	 * @param map - a map of end points.
-	 */
-	private void getEntries(Set<Entry> destination, NavigableMap<TKey, EndPoint> map) {
-		Map.Entry<TKey, EndPoint> last = null;
-		
-		for (Map.Entry<TKey, EndPoint> entry : map.entrySet()) {
-			switch (entry.getValue().state) {
-			case BOTH:
-				EndPoint point = entry.getValue();
-				destination.add(new Entry(point, point));
-				break;
-			case CLOSE:
-				if (last != null) {
-					destination.add(new Entry(last.getValue(), entry.getValue()));
-				}
-				break;
-			case OPEN:
-				// We don't know the full range yet
-				last = entry;
-				break;
-			default:
-				throw new IllegalStateException("Illegal open/close state detected.");
-			}
-		}
-	}
-	
-	/**
-	 * Inserts every range from the given tree into the current tree.
-	 * @param other - the other tree to read from.
-	 */
-	public void putAll(AbstractIntervalTree<TKey, TValue> other) {
-		// Naively copy every range.
-		for (Entry entry : other.entrySet()) {
-			put(entry.left.key, entry.right.key, entry.getValue());
-		}
-	}
-	
-	/**
-	 * Retrieves the value of the range that matches the given key, or NULL if nothing was found.
-	 * @param key - the level to read for.
-	 * @return The correct amount of experience, or NULL if nothing was recorded.
-	 */
-	public TValue get(TKey key) {
-		EndPoint point = getEndPoint(key);
-
-		if (point != null)
-			return point.value;
-		else
-			return null;
-	}
-	
-	/**
-	 * Get the left-most end-point associated with this key.
-	 * @param key - key to search for.
-	 * @return The end point found, or NULL.
-	 */
-	protected EndPoint getEndPoint(TKey key) {
-		EndPoint ends = bounds.get(key);
-		
-		if (ends != null) {
-			// Always return the end point to the left
-			if (ends.state == State.CLOSE) {
-				Map.Entry<TKey, EndPoint> left = bounds.floorEntry(decrementKey(key));
-				return left != null ? left.getValue() : null;
-				
-			} else {
-				return ends;
-			}
-			
-		} else {
-			// We need to determine if the point intersects with a range
-			Map.Entry<TKey, EndPoint> left = bounds.floorEntry(key);
-			
-			// We only need to check to the left
-			if (left != null && left.getValue().state == State.OPEN) {
-				return left.getValue();
-			} else {
-				return null;
-			}
-		}
-	}
-	
-	/**
-	 * Get the previous end point of a given key.
-	 * @param point - the point to search with.
-	 * @param inclusive - whether or not to include the current point in the search.
-	 * @return The previous end point of a given given key, or NULL if not found.
-	 */
-	protected EndPoint getPreviousEndPoint(TKey point, boolean inclusive) {
-		if (point != null) {
-			Map.Entry<TKey, EndPoint> previous = bounds.floorEntry(inclusive ? point : decrementKey(point));
-		
-			if (previous != null)
-				return previous.getValue();
-		}
-		return null;
-	}
-	
-	/**
-	 * Get the next end point of a given key.
-	 * @param point - the point to search with.
-	 * @param inclusive - whether or not to include the current point in the search.
-	 * @return The next end point of a given given key, or NULL if not found.
-	 */
-	protected EndPoint getNextEndPoint(TKey point, boolean inclusive) {
-		if (point != null) {
-			Map.Entry<TKey, EndPoint> next = bounds.ceilingEntry(inclusive ? point : incrementKey(point));
-		
-			if (next != null)
-				return next.getValue();
-		}
-		return null;
-	}
-
-	private void invokeEntryAdded(Entry added) {
-		if (added != null) {
-			onEntryAdded(added);
-		}
-	}
-	
-	private void invokeEntryAdded(Set<Entry> added) {
-		for (Entry entry : added) {
-			onEntryAdded(entry);
-		}
-	}
-
-	private void invokeEntryRemoved(Set<Entry> removed) {
-		for (Entry entry : removed) {
-			onEntryRemoved(entry);
-		}
-	}
-	
-	// Listeners for added or removed entries
-	/**
-	 * Invoked when an entry is added.
-	 * @param added - the entry that was added.
-	 */
-	protected void onEntryAdded(Entry added) { }
-	
-	/**
-	 * Invoked when an entry is removed.
-	 * @param removed - the removed entry.
-	 */
-	protected void onEntryRemoved(Entry removed) { }
-	
-	// Helpers for decrementing or incrementing key values
-	/**
-	 * Decrement the given key by one unit.
-	 * @param key - the key that should be decremented.
-	 * @return The new decremented key.
-	 */
-	protected abstract TKey decrementKey(TKey key);
-	
-	/**
-	 * Increment the given key by one unit.
-	 * @param key - the key that should be incremented.
-	 * @return The new incremented key.
-	 */
-	protected abstract TKey incrementKey(TKey key);
-}

modules/API/src/main/java/com/comphenix/protocol/concurrency/BlockingHashMap.java

@@ -1,266 +0,0 @@
-/*
- *  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 java.util.Collection;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-import java.util.concurrent.TimeUnit;
-
-import com.comphenix.protocol.utility.SafeCacheBuilder;
-import com.google.common.cache.CacheLoader;
-import com.google.common.cache.RemovalCause;
-import com.google.common.cache.RemovalListener;
-import com.google.common.cache.RemovalNotification;
-
-/**
- * A map that supports blocking on read operations. Null keys are not supported.
- * <p>
- * Values are stored as weak references, and will be automatically removed once they've all been dereferenced.
- * <p>
- * @author Kristian
- *
- * @param <TKey> - type of the key.
- * @param <TValue> - type of the value.
- */
-public class BlockingHashMap<TKey, TValue> {
-	// Map of values
-	private final ConcurrentMap<TKey, TValue> backingMap;
-	
-	// Map of locked objects
-	private final ConcurrentMap<TKey, Object> locks;
-	
-	/**
-	 * Retrieve a cache loader that will always throw an exception.
-	 * @param <TKey> Type of the key
-	 * @param <TValue> Type of the value
-	 * @return An invalid cache loader.
-	 */
-	public static <TKey, TValue> CacheLoader<TKey, TValue> newInvalidCacheLoader() {
-		return new CacheLoader<TKey, TValue>() {
-			@Override
-			public TValue load(TKey key) throws Exception {
-				throw new IllegalStateException("Illegal use. Access the map directly instead.");
-			}
-		};
-	}
-	
-	/**
-	 * Initialize a new map.
-	 */
-	public BlockingHashMap() {
-		backingMap = SafeCacheBuilder.<TKey, TValue>newBuilder().
-			weakValues().
-			removalListener(
-				new RemovalListener<TKey, TValue>() {
-					@Override
-					public void onRemoval(RemovalNotification<TKey, TValue> entry) {
-						// Clean up locks too
-						if (entry.getCause() != RemovalCause.REPLACED) {
-							locks.remove(entry.getKey());
-						}
-					}
-				}).
-			build(BlockingHashMap.<TKey, TValue> newInvalidCacheLoader());
-		
-		// Normal concurrent hash map
-		locks = new ConcurrentHashMap<TKey, Object>();
-	}
-	
-	/**
-	 * Initialize a new map.
-	 * @param <TKey> Type of the key
-	 * @param <TValue> Type of the value
-	 * @return The created map.
-	 */
-	public static <TKey, TValue> BlockingHashMap<TKey, TValue> create() {
-		return new BlockingHashMap<TKey, TValue>();
-	}
-	
-	/**
-	 * Waits until a value has been associated with the given key, and then retrieves that value.
-	 * @param key - the key whose associated value is to be returned
-	 * @return The value to which the specified key is mapped.
-	 * @throws InterruptedException If the current thread got interrupted while waiting.
-	 */
-	public TValue get(TKey key) throws InterruptedException {
-		if (key == null)
-			throw new IllegalArgumentException("key cannot be NULL.");
-		
-		TValue value = backingMap.get(key);
-		
-		// Only lock if no value is available
-		if (value == null) {
-			final Object lock = getLock(key);
-			
-			synchronized (lock) {
-				while (value == null) {
-					lock.wait();
-					value = backingMap.get(key);
-				}
-			}
-		}
-		
-		return value;
-	}
-	
-	/**
-	 * Waits until a value has been associated with the given key, and then retrieves that value.
-	 * @param key - the key whose associated value is to be returned
-	 * @param timeout - the amount of time to wait until an association has been made.
-	 * @param unit - unit of timeout.
-	 * @return The value to which the specified key is mapped, or NULL if the timeout elapsed.
-	 * @throws InterruptedException If the current thread got interrupted while waiting.
-	 */
-	public TValue get(TKey key, long timeout, TimeUnit unit) throws InterruptedException {
-		return get(key, timeout, unit, false);
-	}
-	
-	/**
-	 * Waits until a value has been associated with the given key, and then retrieves that value.
-	 * <p>
-	 * If timeout is zero, this method will return immediately if it can't find an socket injector.
-	 * 
-	 * @param key - the key whose associated value is to be returned
-	 * @param timeout - the amount of time to wait until an association has been made.
-	 * @param unit - unit of timeout.
-	 * @param ignoreInterrupted - TRUE if we should ignore the thread being interrupted, FALSE otherwise.
-	 * @return The value to which the specified key is mapped, or NULL if the timeout elapsed.
-	 * @throws InterruptedException If the current thread got interrupted while waiting.
-	 */
-	public TValue get(TKey key, long timeout, TimeUnit unit, boolean ignoreInterrupted) throws InterruptedException {
-		if (key == null)
-			throw new IllegalArgumentException("key cannot be NULL.");
-		if (unit == null)
-			throw new IllegalArgumentException("Unit cannot be NULL.");
-		if (timeout < 0)
-			throw new IllegalArgumentException("Timeout cannot be less than zero.");
-		
-		TValue value = backingMap.get(key);
-		
-		// Only lock if no value is available
-		if (value == null && timeout > 0) {
-			final Object lock = getLock(key);
-			final long stopTimeNS = System.nanoTime() + unit.toNanos(timeout);
-			
-			// Don't exceed the timeout
-			synchronized (lock) {
-				while (value == null) {
-					try {
-						long remainingTime = stopTimeNS - System.nanoTime();
-						
-						if (remainingTime > 0) {
-							TimeUnit.NANOSECONDS.timedWait(lock, remainingTime);
-							value = backingMap.get(key);
-						} else {
-							// Timeout elapsed
-							break;
-						}
-					} catch (InterruptedException e) {
-						// This is fairly dangerous - but we might HAVE to block the thread
-						if (!ignoreInterrupted)
-							throw e;
-					}
-				}
-			}
-		}
-		return value;
-	}
-	
-	/**
-	 * Associate a given key with the given value.
-	 * <p>
-	 * Wakes up any blocking getters on this specific key.
-	 * 
-	 * @param key - the key to associate.
-	 * @param value - the value.
-	 * @return The previously associated value.
-	 */
-	public TValue put(TKey key, TValue value) {
-		if (value == null)
-			throw new IllegalArgumentException("This map doesn't support NULL values.");
-		
-		final TValue previous = backingMap.put(key, value);
-		final Object lock = getLock(key);
-		
-		// Inform our readers about this change
-		synchronized (lock) {
-			lock.notifyAll();
-			return previous;
-		}
-	}
-	
-	/**
-	 * If and only if a key is not present in the map will it be associated with the given value.
-	 * @param key - the key to associate.
-	 * @param value - the value to associate.
-	 * @return The previous value this key has been associated with.
-	 */
-	public TValue putIfAbsent(TKey key, TValue value) {
-		if (value == null)
-			throw new IllegalArgumentException("This map doesn't support NULL values.");
-		
-		final TValue previous = backingMap.putIfAbsent(key, value);
-		
-		// No need to unlock readers if we haven't changed anything
-		if (previous == null) {
-			final Object lock = getLock(key);
-			
-			synchronized (lock) {
-				lock.notifyAll();
-			}
-		}
-		return previous;
-	}
-	
-	public int size() {
-		return backingMap.size();
-	}
-	
-	public Collection<TValue> values() {
-		return backingMap.values();
-	}
-	
-	public Set<TKey> keys() {
-		return backingMap.keySet();
-	}
-	
-	/**
-	 * Atomically retrieve the lock associated with a given key.
-	 * @param key - the current key.
-	 * @return An asssociated lock.
-	 */
-	private Object getLock(TKey key) {
-		Object lock = locks.get(key);
-		
-		if (lock == null) {
-			Object created = new Object();
-			
-			// Do this atomically
-			lock = locks.putIfAbsent(key, created);
-			
-			// If we succeeded, use the latch we created - otherwise, use the already inserted latch
-			if (lock == null) {
-				lock = created;
-			}
-		}
-		
-		return lock;
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/concurrency/ConcurrentPlayerMap.java

@@ -1,332 +0,0 @@
-package com.comphenix.protocol.concurrency;
-
-import java.util.AbstractMap;
-import java.util.AbstractSet;
-import java.util.Iterator;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-
-import org.bukkit.entity.Player;
-
-import com.comphenix.protocol.utility.SafeCacheBuilder;
-import com.comphenix.protocol.utility.Util;
-import com.google.common.base.Function;
-import com.google.common.cache.CacheLoader;
-import com.google.common.cache.RemovalListener;
-import com.google.common.cache.RemovalNotification;
-import com.google.common.collect.AbstractIterator;
-import com.google.common.collect.Maps;
-import com.google.common.util.concurrent.UncheckedExecutionException;
-
-/**
- * Represents a concurrent player map.
- * <p>
- * This map may use player addresses as keys.
- * @author Kristian
- */
-public class ConcurrentPlayerMap<TValue> extends AbstractMap<Player, TValue> implements ConcurrentMap<Player, TValue> {
-	/**
-	 * Represents the different standard player keys,
-	 * @author Kristian
-	 */
-	public enum PlayerKey implements Function<Player, Object> {
-		/**
-		 * Use a player's {@link Player#getAddress()} as key in the map.
-		 */
-		ADDRESS {
-			@Override
-			public Object apply(Player player) {
-				return player.getAddress();
-			}
-		},
-		
-		/**
-		 * Use a player's {@link Player#getName()} as key in the map.
-		 */
-		NAME {
-			@Override
-			public Object apply(Player player) {
-				return player.getName();
-			}
-		},
-	}
-	
-	/**
-	 * An internal map of player keys to values.
-	 */
-	protected ConcurrentMap<Object, TValue> valueLookup = createValueMap();
-	
-	/**
-	 * A cache of the associated keys for each player.
-	 */
-	
-	protected ConcurrentMap<Object, Player> keyLookup = createKeyCache();
-	/**
-	 * The method used to retrieve a unique key for a player.
-	 */
-	protected final Function<Player, Object> keyMethod;
-	
-	/**
-	 * Construct a new concurrent player map that uses each player's address as key.
-	 * @param <T> Parameter type
-	 * @return Concurrent player map.
-	 */
-	public static <T> ConcurrentPlayerMap<T> usingAddress() {
-		return new ConcurrentPlayerMap<T>(PlayerKey.ADDRESS);
-	}
-	
-	/**
-	 * Construct a new concurrent player map that uses each player's name as key.
-	 * @param <T> Parameter type
-	 * @return Concurrent player map.
-	 */
-	public static <T> ConcurrentPlayerMap<T> usingName() {
-		return new ConcurrentPlayerMap<T>(PlayerKey.NAME);
-	}
-	
-	/**
-	 * Construct a new concurrent player map using the given standard key method.
-	 * @param standardMethod - the standard key method.
-	 */
-	public ConcurrentPlayerMap(PlayerKey standardMethod) {
-		this.keyMethod = standardMethod;
-	}
-	
-	/**
-	 * Construct a new concurrent player map using the given custom key method.
-	 * @param method - custom key method.
-	 */
-	public ConcurrentPlayerMap(Function<Player, Object> method) {
-		this.keyMethod = method;
-	}
-	
-	/**
-	 * Construct the map that will store the associated values.
-	 * <p>
-	 * The default implementation uses a {@link ConcurrentHashMap}.
-	 * @return The value map.
-	 */
-	protected ConcurrentMap<Object, TValue> createValueMap() {
-		return Maps.newConcurrentMap();
-	}
-	
-	/**
-	 * Construct a cache of keys and the associated player.
-	 * @return The key map.
-	 */
-	protected ConcurrentMap<Object, Player> createKeyCache() {
-		return SafeCacheBuilder.newBuilder().
-			weakValues().
-			removalListener(
-			  new RemovalListener<Object, Player>() {
-				@Override
-				public void onRemoval(RemovalNotification<Object, Player> removed) {
-					// We ignore explicit removal
-					if (removed.wasEvicted()) {
-						onCacheEvicted(removed.getKey());
-					}
-				}
-			}).
-			build(
-			  new CacheLoader<Object, Player>() {
-				@Override
-				public Player load(Object key) throws Exception {
-					Player player = findOnlinePlayer(key);
-					
-					if (player != null)
-						return player;
-					
-					// Per the contract, this method should not return NULL
-					throw new IllegalArgumentException(
-							"Unable to find a player associated with: " + key);
-				}
-			});
-	}
-	
-	/**
-	 * Invoked when an entry in the cache has been evicted, typically by the garbage collector.
-	 * @param key - the key.
-	 * @param player - the value that was evicted or collected.
-	 */
-	private void onCacheEvicted(Object key) {
-		Player newPlayer = findOnlinePlayer(key);
-		
-		if (newPlayer != null) {
-			// Update the reference
-			keyLookup.put(key, newPlayer);
-		} else {
-			valueLookup.remove(key);
-		}
-	}
-	
-	/**
-	 * Find an online player from the given key.
-	 * @param key - a non-null key.
-	 * @return The player with the given key, or NULL if not found.
-	 */
-	protected Player findOnlinePlayer(Object key) {
-		for (Player player : Util.getOnlinePlayers()) {
-			if (key.equals(keyMethod.apply(player))) {
-				return player;
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * Lookup a player by key in the cache, optionally searching every online player.
-	 * @param key - the key of the player we are locating.
-	 * @return The player, or NULL if not found.
-	 */
-	protected Player lookupPlayer(Object key) {
-		try {
-			return keyLookup.get(key);
-		} catch (UncheckedExecutionException e) {
-			return null;
-		}
-	}
-	
-	/**
-	 * Retrieve the key of a particular player, ensuring it is cached.
-	 * @param player - the player whose key we want to retrieve.
-	 * @return The key.
-	 */
-	protected Object cachePlayerKey(Player player) {
-		Object key = keyMethod.apply(player);
-		
-		keyLookup.put(key, player);
-		return key;
-	}
-	
-	@Override
-	public TValue put(Player key, TValue value) {
-		return valueLookup.put(cachePlayerKey(key), value);
-	}
-	
-	@Override
-	public TValue putIfAbsent(Player key, TValue value) {
-		return valueLookup.putIfAbsent(cachePlayerKey(key), value);
-	}
-	
-	@Override
-	public TValue replace(Player key, TValue value) {
-		return valueLookup.replace(cachePlayerKey(key), value);
-	}
-	
-	@Override
-	public boolean replace(Player key, TValue oldValue, TValue newValue) {
-		return valueLookup.replace(cachePlayerKey(key), oldValue, newValue);
-	}
-
-	@Override
-	public TValue remove(Object key) {
-		if (key instanceof Player) {
-			Object playerKey = keyMethod.apply((Player) key);
-			
-			if (playerKey != null) {
-				TValue value = valueLookup.remove(playerKey);
-			
-				keyLookup.remove(playerKey);
-				return value;
-			}
-		}
-		return null;
-	}
-	
-	@Override
-	public boolean remove(Object key, Object value) {
-		if (key instanceof Player) {
-			Object playerKey = keyMethod.apply((Player) key);
-			
-			if (playerKey != null && valueLookup.remove(playerKey, value)) {
-				keyLookup.remove(playerKey);
-				return true;
-			}
-		}
-		return false;
-	}
-	
-	@Override
-	public TValue get(Object key) {
-		if (key instanceof Player) {
-			Object playerKey = keyMethod.apply((Player) key);
-			return playerKey != null ? valueLookup.get(playerKey) : null;
-		}
-		return null;
-	}
-	
-	@Override
-	public boolean containsKey(Object key) {
-		if (key instanceof Player) {
-			Object playerKey = keyMethod.apply((Player) key);
-			return playerKey != null && valueLookup.containsKey(playerKey);
-		}
-		return false;
-	}
-		
-	@Override
-	public Set<Entry<Player, TValue>> entrySet() {
-		return new AbstractSet<Entry<Player,TValue>>() {
-			@Override
-			public Iterator<Entry<Player, TValue>> iterator() {
-				return entryIterator();
-			}
-		
-			@Override
-			public int size() {
-				return valueLookup.size();
-			}
-			
-			@Override
-			public void clear() {
-				valueLookup.clear();
-				keyLookup.clear();
-			}
-		};
-	}
-
-	/**
-	 * Retrieve an iterator of entries that supports removal of elements.
-	 * @return Entry iterator.
-	 */
-	private Iterator<Entry<Player, TValue>> entryIterator() {
-		// Skip entries with stale data
-		final Iterator<Entry<Object, TValue>> source = valueLookup.entrySet().iterator();
-		final AbstractIterator<Entry<Player,TValue>> filtered =
-		  new AbstractIterator<Entry<Player,TValue>>() {
-			@Override
-			protected Entry<Player, TValue> computeNext() {
-				while (source.hasNext()) {
-					Entry<Object, TValue> entry = source.next();
-					Player player = lookupPlayer(entry.getKey());
-					
-					if (player == null) {
-						// Remove entries that cannot be found
-						source.remove();
-						keyLookup.remove(entry.getKey());
-					} else {
-						return new SimpleEntry<Player, TValue>(player, entry.getValue());
-					}
-				}
-				return endOfData();
-			}
-		};
-		
-		// We can't return AbstractIterator directly, as it doesn't permitt the remove() method
-		return new Iterator<Entry<Player, TValue>>() {
-			@Override
-			public boolean hasNext() {
-				return filtered.hasNext();
-			}
-			@Override
-			public Entry<Player, TValue> next() {
-				return filtered.next();
-			}
-			@Override
-			public void remove() {
-				source.remove();
-			}
-		};
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/concurrency/IntegerSet.java

@@ -1,116 +0,0 @@
-/*
- *  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 java.util.Arrays;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Set;
-
-/**
- * Represents a very quick integer set that uses a lookup table to store membership.
- * <p>
- * This class is intentionally missing a size method.
- * @author Kristian
- */
-public class IntegerSet {
-	private final boolean[] array;
-
-	/**
-	 * Initialize a lookup table with the given maximum number of elements.
-	 * <p>
-	 * This creates a set for elements in the range [0, count).
-	 * <p>
-	 * Formally, the current set must be a subset of [0, 1, 2, ..., count - 1].
-	 * @param maximumCount - maximum element value and count.
-	 */
-	public IntegerSet(int maximumCount) {
-		this.array = new boolean[maximumCount];
-	}
-	
-	/**
-	 * Initialize a lookup table with a given maximum and value list.
-	 * <p>
-	 * The provided elements must be in the range [0, count).
-	 * @param maximumCount - the maximum element value and count.
-	 * @param values - the elements to add to the set.
-	 */
-	public IntegerSet(int maximumCount, Collection<Integer> values) {
-		this.array = new boolean[maximumCount];
-		addAll(values);
-	}
-	
-	/**
-	 * Determine whether or not the given element exists in the set.
-	 * @param element - the element to check. Must be in the range [0, count).
-	 * @return TRUE if the given element exists, FALSE otherwise.
-	 */
-	public boolean contains(int element) {
-		return array[element];
-	}
-	
-	/**
-	 * Add the given element to the set, or do nothing if it already exists.
-	 * @param element - element to add.
-	 * @throws ArrayIndexOutOfBoundsException If the given element is not in the range [0, count).
-	 */
-	public void add(int element) {
-		array[element] = true;
-	}
-	
-	/**
-	 * Add the given collection of elements to the set.
-	 * @param packets - elements to add.
-	 */
-	public void addAll(Collection<Integer> packets) {
-		for (Integer id : packets) {
-			add(id);
-		}
-	}
-	
-	/**
-	 * Remove the given element from the set, or do nothing if it's already removed.
-	 * @param element - element to remove.
-	 */
-	public void remove(int element) {
-		// We don't actually care if the caller tries to remove an element outside the valid set
-		if (element >= 0 && element < array.length)
-			array[element] = false;
-	}
-	
-	/**
-	 * Remove every element from the set.
-	 */
-	public void clear() {
-		Arrays.fill(array, false);
-	}
-	
-	/**
-	 * Convert the current IntegerSet to an equivalent HashSet.
-	 * @return The resulting HashSet.
-	 */
-	public Set<Integer> toSet() {
-		Set<Integer> elements = new HashSet<Integer>();
-		
-		for (int i = 0; i < array.length; i++) {
-			if (array[i])
-				elements.add(i);
-		}
-		return elements;
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/concurrency/PacketTypeSet.java

@@ -1,134 +0,0 @@
-package com.comphenix.protocol.concurrency;
-
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Set;
-
-import com.comphenix.protocol.PacketType;
-import com.comphenix.protocol.injector.packet.PacketRegistry;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.Maps;
-
-/**
- * Represents a concurrent set of packet types.
- * @author Kristian
- */
-public class PacketTypeSet {
-	private Set<PacketType> types = Collections.newSetFromMap(Maps.<PacketType, Boolean>newConcurrentMap());
-	private Set<Class<?>> classes = Collections.newSetFromMap(Maps.<Class<?>, Boolean>newConcurrentMap());
-	
-	public PacketTypeSet() {
-		// Do nothing
-	}
-	
-	public PacketTypeSet(Collection<? extends PacketType> values) {
-		for (PacketType type : values) {
-			addType(type);
-		}
-	}
-	
-	/**
-	 * Add a particular type to the set.
-	 * @param type - the type to add.
-	 */
-	public synchronized void addType(PacketType type) {
-		Class<?> packetClass = getPacketClass(type);
-		types.add(Preconditions.checkNotNull(type, "type cannot be NULL."));
-		
-		if (packetClass != null) {
-			classes.add(getPacketClass(type));
-		}
-	}
-	
-	/**
-	 * Add the given types to the set of packet types.
-	 * @param types - the types to add.
-	 */
-	public synchronized void addAll(Iterable<? extends PacketType> types) {
-		for (PacketType type : types) {
-			addType(type);
-		}
-	}
-	
-	/**
-	 * Remove a particular type to the set.
-	 * @param type - the type to remove.
-	 */
-	public synchronized void removeType(PacketType type) {
-		Class<?> packetClass = getPacketClass(type);
-		types.remove(Preconditions.checkNotNull(type, "type cannot be NULL."));
-		
-		if (packetClass != null) {
-			classes.remove(getPacketClass(type));
-		}
-	}
-	
-	/**
-	 * Remove the given types from the set.
-	 * @param types Types to remove
-	 */
-	public synchronized void removeAll(Iterable<? extends PacketType> types) {
-		for (PacketType type : types) {
-			removeType(type);
-		}
-	}
-	
-	/**
-	 * Retrieve the packet class associated with a particular type.
-	 * @param type - the packet type.
-	 * @return The associated packet type.
-	 */
-	protected Class<?> getPacketClass(PacketType type) {
-		return PacketRegistry.getPacketClassFromType(type);
-	}
-	
-	/**
-	 * Determine if the given packet type exists in the set.
-	 * @param type - the type to find.
-	 * @return TRUE if it does, FALSE otherwise.
-	 */
-	public boolean contains(PacketType type) {
-		return types.contains(type);
-	}
-	
-	/**
-	 * Determine if a packet type with the given packet class exists in the set.
-	 * @param packetClass - the class to find.
-	 * @return TRUE if it does, FALSE otherwise.
-	 */
-	public boolean contains(Class<?> packetClass) {
-		return classes.contains(packetClass);
-	}
-	
-	/**
-	 * Determine if the type of a packet is in the current set.
-	 * @param packet - the packet.
-	 * @return TRUE if it is, FALSE otherwise.
-	 */
-	public boolean containsPacket(Object packet) {
-		if (packet == null)
-			return false;
-		return classes.contains(packet.getClass());
-	}
-	
-	/**
-	 * Retrieve a view of this packet type set.
-	 * @return The packet type values.
-	 */
-	public Set<PacketType> values() {
-		return types;
-	}
-	
-	/**
-	 * Retrieve the number of entries in the set.
-	 * @return The number of entries.
-	 */
-	public int size() {
-		return types.size();
-	}
-	
-	public synchronized void clear() {
-		types.clear();
-		classes.clear();
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/concurrency/SortedCopyOnWriteArray.java

@@ -1,244 +0,0 @@
-/*
- *  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 java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.List;
-
-import com.google.common.base.Objects;
-import com.google.common.collect.Iterables;
-
-/**
- * An implicitly sorted array list that preserves insertion order and maintains duplicates.
- * @param <T> - type of the elements in the list.
- */
-public class SortedCopyOnWriteArray<T extends Comparable<T>> implements Collection<T> {
-	// Prevent reordering
-	private volatile List<T> list;
-	
-	/**
-	 * Construct an empty sorted array.
-	 */
-	public SortedCopyOnWriteArray() {
-		list = new ArrayList<T>();
-	}
-	
-	/**
-	 * Create a sorted array from the given list. The elements will be automatically sorted.
-	 * @param wrapped - the collection whose elements are to be placed into the list.
-	 */
-	public SortedCopyOnWriteArray(Collection<T> wrapped) {
-		this.list = new ArrayList<T>(wrapped);
-	}
-	
-	/**
-	 * Create a sorted array from the given list. 
-	 * @param wrapped - the collection whose elements are to be placed into the list.
-	 * @param sort - TRUE to automatically sort the collection, FALSE if it is already sorted. 
-	 */
-	public SortedCopyOnWriteArray(Collection<T> wrapped, boolean sort) {
-		this.list = new ArrayList<T>(wrapped);
-		
-		if (sort) {
-			Collections.sort(list);
-		}
-	}
-	
-	/**
-	 * Inserts the given element in the proper location.
-	 * @param value - element to insert.
-	 */
-	@Override
-	public synchronized boolean add(T value) {
-    	// We use NULL as a special marker, so we don't allow it
-    	if (value == null)
-    		throw new IllegalArgumentException("value cannot be NULL");
-    	
-    	List<T> copy = new ArrayList<T>();
-
-        for (T element : list) {
-        	// If the value is now greater than the current element, it should be placed right before it
-        	if (value != null && value.compareTo(element) < 0) {
-        		copy.add(value);
-        		value = null;
-        	}
-        	copy.add(element);
-        }
-        
-        // Don't forget to add it
-        if (value != null)
-        	copy.add(value);
-        
-        list = copy;
-        return true;
-    }
-    
-	@Override
-    public synchronized boolean addAll(Collection<? extends T> values) {
-		if (values == null)
-			throw new IllegalArgumentException("values cannot be NULL");
-		if (values.size() == 0)
-			return false;
-		
-    	List<T> copy = new ArrayList<T>();
-    	
-    	// Insert the new content and sort it
-    	copy.addAll(list);
-    	copy.addAll(values);
-    	Collections.sort(copy);
-    	
-    	list = copy;
-    	return true;
-    }
-    
-    /**
-     * Removes from the list by making a new list with every element except the one given.
-     * <p>
-     * Objects will be compared using the given objects equals() method.
-     * @param value - value to remove.
-     */
-	@Override
-    public synchronized boolean remove(Object value) {
-    	List<T> copy = new ArrayList<T>();
-    	boolean result = false;
-    	
-    	// Note that there's not much to be gained from using BinarySearch, as we
-    	// have to copy (and thus read) the entire list regardless.
-    	
-    	// Copy every element except the one given to us. 
-    	for (T element : list) {
-    		if (!Objects.equal(value, element)) {
-    			copy.add(element);    			
-    		} else {
-    			result = true;
-    		}
-    	}
-
-    	list = copy;
-    	return result;
-    }
-    
-	@Override
-	public boolean removeAll(Collection<?> values) {
-		// Special cases
-		if (values == null)
-			throw new IllegalArgumentException("values cannot be NULL");
-		if (values.size() == 0)
-			return false;
-		
-		List<T> copy = new ArrayList<T>();
-		
-		copy.addAll(list);
-		copy.removeAll(values);
-		
-		list = copy;
-		return true;
-	}
-
-	@Override
-	public boolean retainAll(Collection<?> values) {
-		// Special cases
-		if (values == null)
-			throw new IllegalArgumentException("values cannot be NULL");
-		if (values.size() == 0)
-			return false;
-		
-		List<T> copy = new ArrayList<T>();
-		
-		copy.addAll(list);
-		copy.removeAll(values);
-		
-		list = copy;
-		return true;
-	}
-	
-    /**
-     * Removes from the list by making a copy of every element except the one with the given index.
-     * @param index - index of the element to remove.
-     */
-    public synchronized void remove(int index) {
-    	List<T> copy = new ArrayList<T>(list);
-    	
-    	copy.remove(index);
-    	list = copy;
-    }
-    
-    /**
-     * Retrieves an element by index. 
-     * @param index - index of element to retrieve.
-     * @return The element at the given location.
-     */
-    public T get(int index) {
-    	return list.get(index);
-    }
-    
-    /**
-     * Retrieve the size of the list.
-     * @return Size of the list.
-     */
-    public int size() {
-    	return list.size();
-    }
-
-    /**
-     * Retrieves an iterator over the elements in the given list. 
-     * Warning: No not attempt to remove elements using the iterator.
-     */
-	public Iterator<T> iterator() {
-		return Iterables.unmodifiableIterable(list).iterator();
-	}
-	
-	@Override
-	public void clear() {
-		list = new ArrayList<T>();
-	}
-
-	@Override
-	public boolean contains(Object value) {
-		return list.contains(value);
-	}
-
-	@Override
-	public boolean containsAll(Collection<?> values) {
-		return list.containsAll(values);
-	}
-
-	@Override
-	public boolean isEmpty() {
-		return list.isEmpty();
-	}
-
-	@Override
-	public Object[] toArray() {
-		return list.toArray();
-	}
-
-	@SuppressWarnings("hiding")
-	@Override
-	public <T> T[] toArray(T[] a) {
-		return list.toArray(a);
-	}
-	
-	@Override
-	public String toString() {
-		return list.toString();
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/error/BasicErrorReporter.java

@@ -1,107 +0,0 @@
-package com.comphenix.protocol.error;
-
-import java.io.PrintStream;
-
-import org.bukkit.plugin.Plugin;
-
-import com.comphenix.protocol.error.Report.ReportBuilder;
-import com.comphenix.protocol.reflect.PrettyPrinter;
-
-/**
- * Represents a basic error reporter that prints error reports to the standard error stream.
- * <p>
- * Note that this implementation doesn't distinguish between {@link #reportWarning(Object, Report)} 
- * and {@link #reportDetailed(Object, Report)} - they both have the exact same behavior.
- * @author Kristian
- */
-public class BasicErrorReporter implements ErrorReporter {
-	private final PrintStream output;
-	
-	/**
-	 * Construct a new basic error reporter that prints directly the standard error stream.
-	 */
-	public BasicErrorReporter() {
-		 this(System.err);
-	}
-	
-	/**
-	 * Construct a error reporter that prints to the given output stream.
-	 * @param output - the output stream.
-	 */
-	public BasicErrorReporter(PrintStream output) {
-		this.output = output;
-	}
-
-	@Override
-	public void reportMinimal(Plugin sender, String methodName, Throwable error) {
-		output.println("Unhandled exception occured in " +  methodName + " for " + sender.getName());
-		error.printStackTrace(output);
-	}
-
-	@Override
-	public void reportMinimal(Plugin sender, String methodName, Throwable error, Object... parameters) {
-		reportMinimal(sender, methodName, error);
-		
-		// Also print parameters
-		printParameters(parameters);
-	}
-
-	@Override
-	public void reportDebug(Object sender, Report report) {
-		// We just have to swallow it
-	}
-
-	@Override
-	public void reportDebug(Object sender, ReportBuilder builder) {
-		// As above
-	}
-	
-	@Override
-	public void reportWarning(Object sender, Report report) {
-		// Basic warning
-		output.println("[" + sender.getClass().getSimpleName() + "] " + report.getReportMessage());
-		
-		if (report.getException() != null) {
-			report.getException().printStackTrace(output);
-		}
-		printParameters(report.getCallerParameters());
-	}
-
-	@Override
-	public void reportWarning(Object sender, ReportBuilder reportBuilder) {
-		reportWarning(sender, reportBuilder.build());
-	}
-
-	@Override
-	public void reportDetailed(Object sender, Report report) {
-		// No difference from warning
-		reportWarning(sender, report);
-	}
-
-	@Override
-	public void reportDetailed(Object sender, ReportBuilder reportBuilder) {
-		reportWarning(sender, reportBuilder);
-	}
-	
-	/**
-	 * Print the given parameters to the standard error stream.
-	 * @param parameters - the output parameters.
-	 */
-	private void printParameters(Object[] parameters) {
-		if (parameters != null && parameters.length > 0) {
-			output.println("Parameters: ");
-			
-			try {
-				for (Object parameter : parameters) {
-					if (parameter == null)
-						output.println("[NULL]");
-					else
-						output.println(PrettyPrinter.printObject(parameter));
-				}
-			} catch (IllegalAccessException e) {
-				// Damn it
-				e.printStackTrace();
-			}
-		}
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/error/DelegatedErrorReporter.java

@@ -1,94 +0,0 @@
-package com.comphenix.protocol.error;
-
-import org.bukkit.plugin.Plugin;
-
-import com.comphenix.protocol.error.Report.ReportBuilder;
-
-/**
- * Construct an error reporter that delegates to another error reporter.
- * @author Kristian
- */
-public class DelegatedErrorReporter implements ErrorReporter {
-	private final ErrorReporter delegated;
-
-	/**
-	 * Construct a new error reporter that forwards all reports to a given reporter.
-	 * @param delegated - the delegated reporter.
-	 */
-	public DelegatedErrorReporter(ErrorReporter delegated) {
-		this.delegated = delegated;
-	}
-	
-	/**
-	 * Retrieve the underlying error reporter.
-	 * @return Underlying error reporter.
-	 */
-	public ErrorReporter getDelegated() {
-		return delegated;
-	}
-
-	@Override
-	public void reportMinimal(Plugin sender, String methodName, Throwable error) {
-		delegated.reportMinimal(sender, methodName, error);
-	}
-
-	@Override
-	public void reportMinimal(Plugin sender, String methodName, Throwable error, Object... parameters) {
-		delegated.reportMinimal(sender, methodName, error, parameters);
-	}
-
-	@Override
-	public void reportDebug(Object sender, Report report) {
-		Report transformed = filterReport(sender, report, false);
-		
-		if (transformed != null) {
-			delegated.reportDebug(sender, transformed);
-		}
-	}
-	
-	@Override
-	public void reportWarning(Object sender, Report report) {
-		Report transformed = filterReport(sender, report, false);
-		
-		if (transformed != null) {
-			delegated.reportWarning(sender, transformed);
-		}
-	}
-
-	@Override
-	public void reportDetailed(Object sender, Report report) {
-		Report transformed = filterReport(sender, report, true);
-		
-		if (transformed != null) {
-			delegated.reportDetailed(sender, transformed);
-		}
-	}
-
-	/**
-	 * Invoked before an error report is passed on to the underlying error reporter.
-	 * <p>
-	 * To cancel a report, return NULL.
-	 * @param sender - the sender instance or class.
-	 * @param report - the error report.
-	 * @param detailed - whether or not the report will be displayed in detail.
-	 * @return The report to pass on, or NULL to cancel it.
-	 */
-	protected Report filterReport(Object sender, Report report, boolean detailed) {
-		return report;
-	}
-	
-	@Override
-	public void reportWarning(Object sender, ReportBuilder reportBuilder) {
-		reportWarning(sender, reportBuilder.build());
-	}
-	
-	@Override
-	public void reportDetailed(Object sender, ReportBuilder reportBuilder) {
-		reportDetailed(sender, reportBuilder.build());
-	}
-	
-	@Override
-	public void reportDebug(Object sender, ReportBuilder builder) {
-		reportDebug(sender, builder.build());
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/error/DetailedErrorReporter.java

@@ -1,618 +0,0 @@
-/*
- *  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.error;
-
-import java.io.PrintWriter;
-import java.io.StringWriter;
-import java.lang.ref.WeakReference;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import org.apache.commons.lang.builder.ToStringBuilder;
-import org.apache.commons.lang.builder.ToStringStyle;
-import org.bukkit.Bukkit;
-import org.bukkit.plugin.Plugin;
-
-import com.comphenix.protocol.ProtocolLogger;
-import com.comphenix.protocol.collections.ExpireHashMap;
-import com.comphenix.protocol.error.Report.ReportBuilder;
-import com.comphenix.protocol.events.PacketAdapter;
-import com.comphenix.protocol.reflect.PrettyPrinter;
-import com.google.common.base.Preconditions;
-import com.google.common.primitives.Primitives;
-
-/**
- * Internal class used to handle exceptions.
- * 
- * @author Kristian
- */
-public class DetailedErrorReporter implements ErrorReporter {
-	/**
-	 * Report format for printing the current exception count.
-	 */
-	public static final ReportType REPORT_EXCEPTION_COUNT = new ReportType("Internal exception count: %s!");
-	
-	public static final String SECOND_LEVEL_PREFIX = "  ";
-	public static final String DEFAULT_PREFIX = "  ";
-	public static final String DEFAULT_SUPPORT_URL = "https://github.com/dmulloy2/ProtocolLib/issues";
-
-	// Users that are informed about errors in the chat
-	public static final String ERROR_PERMISSION = "protocol.info";
-	
-	// We don't want to spam the server
-	public static final int DEFAULT_MAX_ERROR_COUNT = 20;
-	
-	// Prevent spam per plugin too
-	private ConcurrentMap<String, AtomicInteger> warningCount = new ConcurrentHashMap<String, AtomicInteger>();
-	
-	protected String prefix;
-	protected String supportURL;
-	
-	protected AtomicInteger internalErrorCount = new AtomicInteger();
-	
-	protected int maxErrorCount;
-	protected Logger logger;
-	
-	protected WeakReference<Plugin> pluginReference;
-	protected String pluginName;
-	
-	// Whether or not Apache Commons is not present
-	protected static boolean apacheCommonsMissing;
-	
-	// Whether or not detailed errror reporting is enabled
-	protected boolean detailedReporting;
-	
-	// Map of global objects
-	protected Map<String, Object> globalParameters = new HashMap<String, Object>();
-	
-	// Reports to ignore
-	private ExpireHashMap<Report, Boolean> rateLimited = new ExpireHashMap<Report, Boolean>();
-	private Object rateLock = new Object();
-	
-	/**
-	 * Create a default error reporting system.
-	 * @param plugin - the plugin owner.
-	 */
-	public DetailedErrorReporter(Plugin plugin) {
-		this(plugin, DEFAULT_PREFIX, DEFAULT_SUPPORT_URL);
-	}
-	
-	/**
-	 * Create a central error reporting system.
-	 * @param plugin - the plugin owner.
-	 * @param prefix - default line prefix.
-	 * @param supportURL - URL to report the error.
-	 */
-	public DetailedErrorReporter(Plugin plugin, String prefix, String supportURL) {
-		this(plugin, prefix, supportURL, DEFAULT_MAX_ERROR_COUNT, getBukkitLogger());
-	}
-
-	/**
-	 * Create a central error reporting system.
-	 * @param plugin - the plugin owner.
-	 * @param prefix - default line prefix.
-	 * @param supportURL - URL to report the error.
-	 * @param maxErrorCount - number of errors to print before giving up.
-	 * @param logger - current logger.
-	 */
-	public DetailedErrorReporter(Plugin plugin, String prefix, String supportURL, int maxErrorCount, Logger logger) {
-		if (plugin == null)
-			throw new IllegalArgumentException("Plugin cannot be NULL.");
-		
-		this.pluginReference = new WeakReference<Plugin>(plugin);
-		this.pluginName = getNameSafely(plugin);
-		this.prefix = prefix;
-		this.supportURL = supportURL;
-		this.maxErrorCount = maxErrorCount;
-		this.logger = logger;
-	}
-
-	private String getNameSafely(Plugin plugin) {
-		try {
-			return plugin.getName();
-		} catch (LinkageError e) {
-			return "ProtocolLib";
-		}
-	}
-
-	// Attempt to get the logger.
-	private static Logger getBukkitLogger() {
-		try {
-			return Bukkit.getLogger();
-		} catch (LinkageError e) {
-			return Logger.getLogger("Minecraft");
-		}
-	}
-	
-	/**
-	 * Determine if we're using detailed error reporting.
-	 * @return TRUE if we are, FALSE otherwise.
-	 */
-	public boolean isDetailedReporting() {
-		return detailedReporting;
-	}
-	
-	/**
-	 * Set whether or not to use detailed error reporting.
-	 * @param detailedReporting - TRUE to enable it, FALSE otherwise.
-	 */
-	public void setDetailedReporting(boolean detailedReporting) {
-		this.detailedReporting = detailedReporting;
-	}
-	
-	@Override
-	public void reportMinimal(Plugin sender, String methodName, Throwable error, Object... parameters) {
-		if (reportMinimalNoSpam(sender, methodName, error)) {
-			// Print parameters, if they are given
-			if (parameters != null && parameters.length > 0) {
-				logger.log(Level.SEVERE, printParameters(parameters));
-			}
-		}
-	}
-	
-	@Override
-	public void reportMinimal(Plugin sender, String methodName, Throwable error) {
-		reportMinimalNoSpam(sender, methodName, error);
-	}
-	
-	/**
-	 * Report a problem with a given method and plugin, ensuring that we don't exceed the maximum number of error reports.
-	 * @param sender - the component that observed this exception.
-	 * @param methodName - the method name.
-	 * @param error - the error itself.
-	 * @return TRUE if the error was printed, FALSE if it was suppressed.
-	 */
-	public boolean reportMinimalNoSpam(Plugin sender, String methodName, Throwable error) {
-		String pluginName = PacketAdapter.getPluginName(sender);
-		AtomicInteger counter = warningCount.get(pluginName);
-		
-		// Thread safe pattern
-		if (counter == null) {
-			AtomicInteger created = new AtomicInteger();
-			counter = warningCount.putIfAbsent(pluginName, created);
-			
-			if (counter == null) {
-				counter = created;
-			}
-		}
-		
-		final int errorCount = counter.incrementAndGet();
-		
-		// See if we should print the full error
-		if (errorCount < getMaxErrorCount()) {
-			logger.log(Level.SEVERE, "[" + pluginName + "] Unhandled exception occured in " +
-					 methodName + " for " + pluginName, error);
-			return true;
-			
-		} else {
-			// Nope - only print the error count occationally
-			if (isPowerOfTwo(errorCount)) {
-				logger.log(Level.SEVERE, "[" + pluginName + "] Unhandled exception number " + errorCount + " occured in " +
-						 methodName + " for " + pluginName, error);
-			}
-			return false;
-		}
-	}
-	
-	/**
-	 * Determine if a given number is a power of two.
-	 * <p>
-	 * That is, if there exists an N such that 2^N = number.
-	 * @param number - the number to check.
-	 * @return TRUE if the given number is a power of two, FALSE otherwise.
-	 */
-	private boolean isPowerOfTwo(int number) {
-	    return (number & (number - 1)) == 0;
-	}
-	
-	@Override
-	public void reportDebug(Object sender, ReportBuilder builder) {
-		reportDebug(sender, Preconditions.checkNotNull(builder, "builder cannot be NULL").build());
-	}
-	
-	@Override
-	public void reportDebug(Object sender, Report report) {
-		if (logger.isLoggable(Level.FINE) && canReport(report)) {
-			reportLevel(Level.FINE, sender, report);
-		}
-	}
-	
-	@Override
-	public void reportWarning(Object sender, ReportBuilder reportBuilder) {
-		if (reportBuilder == null)
-			throw new IllegalArgumentException("reportBuilder cannot be NULL.");
-		
-		reportWarning(sender, reportBuilder.build());
-	}
-	
-	@Override
-	public void reportWarning(Object sender, Report report) {
-		if (logger.isLoggable(Level.WARNING) && canReport(report)) {
-			reportLevel(Level.WARNING, sender, report);
-		}
-	}
-	
-	/**
-	 * Determine if we should print the given report.
-	 * <p>
-	 * The default implementation will check for rate limits.
-	 * @param report - the report to check.
-	 * @return TRUE if we should print it, FALSE otherwise.
-	 */
-	protected boolean canReport(Report report) {
-		long rateLimit = report.getRateLimit();
-		
-		// Check for rate limit
-		if (rateLimit > 0) {
-			synchronized (rateLock) {
-				if (rateLimited.containsKey(report)) {
-					return false;
-				}
-				rateLimited.put(report, true, rateLimit, TimeUnit.NANOSECONDS);
-			}
-		}
-		return true;
-	}
-	
-	private void reportLevel(Level level, Object sender, Report report) {
-		String message = "[" + pluginName + "] [" + getSenderName(sender) + "] " + report.getReportMessage();
-		
-		// Print the main warning
-		if (report.getException() != null) {
-			logger.log(level, message, report.getException());
-		} else {
-			logger.log(level, message);
-			
-			// Remember the call stack
-			if (detailedReporting) {
-				printCallStack(level, logger);
-			}
-		}
-		
-		// Parameters?
-		if (report.hasCallerParameters()) {
-			// Write it
-			logger.log(level, printParameters(report.getCallerParameters()));
-		}
-	}
-	
-	/**
-	 * Retrieve the name of a sender class.
-	 * @param sender - sender object.
-	 * @return The name of the sender's class.
-	 */
-	private String getSenderName(Object sender) {
-		if (sender != null)
-			return ReportType.getSenderClass(sender).getSimpleName();
-		else
-			return "NULL";
-	}
-	
-	@Override
-	public void reportDetailed(Object sender, ReportBuilder reportBuilder) {
-		reportDetailed(sender, reportBuilder.build());
-	}
-	
-	@Override
-	public void reportDetailed(Object sender, Report report) {
-		final Plugin plugin = pluginReference.get();
-		final int errorCount = internalErrorCount.incrementAndGet();
-		
-		// Do not overtly spam the server!
-		if (errorCount > getMaxErrorCount()) {
-			// Only allow the error count at rare occations
-			if (isPowerOfTwo(errorCount)) {
-				// Permit it - but print the number of exceptions first
-				reportWarning(this, Report.newBuilder(REPORT_EXCEPTION_COUNT).messageParam(errorCount).build());
-			} else {
-				// NEVER SPAM THE CONSOLE
-				return;
-			}
-		}
-		
-		// Secondary rate limit
-		if (!canReport(report)) {
-			return;
-		}
-		
-		StringWriter text = new StringWriter();
-		PrintWriter writer = new PrintWriter(text);
-
-		// Helpful message
-		writer.println("[" + pluginName + "] INTERNAL ERROR: " + report.getReportMessage());
-	    writer.println("If this problem hasn't already been reported, please open a ticket");
-	    writer.println("at " + supportURL + " with the following data:");
-	    
-	    // Now, let us print important exception information
-		writer.println("Stack Trace:");
-
-		if (report.getException() != null) {
-			report.getException().printStackTrace(writer);
-			
-		} else if (detailedReporting) {
-			printCallStack(writer);
-		}
-		
-		// Data dump!
-		writer.println("Dump:");
-		
-		// Relevant parameters
-		if (report.hasCallerParameters()) {
-			printParameters(writer, report.getCallerParameters());
-		}
-		
-		// Global parameters
-		for (String param : globalParameters()) {
-			writer.println(SECOND_LEVEL_PREFIX + param + ":");
-			writer.println(addPrefix(getStringDescription(getGlobalParameter(param)),
-					SECOND_LEVEL_PREFIX + SECOND_LEVEL_PREFIX));
-		}
-		
-		// Now, for the sender itself
-		writer.println("Sender:");
-		writer.println(addPrefix(getStringDescription(sender), SECOND_LEVEL_PREFIX));
-		
-		// And plugin
-		if (plugin != null) {
-			writer.println("Version:");
-			writer.println(addPrefix(plugin.toString(), SECOND_LEVEL_PREFIX));
-		}
-
-		// And java version
-		writer.println("Java Version:");
-		writer.println(addPrefix(System.getProperty("java.version"), SECOND_LEVEL_PREFIX));
-
-		// Add the server version too
-		if (Bukkit.getServer() != null) {
-			writer.println("Server:");
-			writer.println(addPrefix(Bukkit.getServer().getVersion(), SECOND_LEVEL_PREFIX));
-
-			// Inform of this occurrence
-			if (ERROR_PERMISSION != null) {
-				Bukkit.getServer().broadcast(
-						String.format("Error %s (%s) occured in %s.", report.getReportMessage(), report.getException(), sender),
-						ERROR_PERMISSION
-				);
-			}
-		}
-		
-		// Make sure it is reported
-		logger.severe(addPrefix(text.toString(), prefix));
-	}
-	
-	/**
-	 * Print the call stack to the given logger.
-	 * @param logger - the logger.
-	 */
-	private void printCallStack(Level level, Logger logger) {
-		StringWriter text = new StringWriter();
-		printCallStack(new PrintWriter(text));
-		
-		// Print the exception
-		logger.log(level, text.toString());
-	}
-	
-	/**
-	 * Print the current call stack.
-	 * @param writer - the writer.
-	 */
-	private void printCallStack(PrintWriter writer) {
-		Exception current = new Exception("Not an error! This is the call stack.");
-		current.printStackTrace(writer);
-	}
-	
-	private String printParameters(Object... parameters) {
-		StringWriter writer = new StringWriter();
-		
-		// Print and retrieve the string buffer
-		printParameters(new PrintWriter(writer), parameters);
-		return writer.toString();
-	}
-
-	private void printParameters(PrintWriter writer, Object[] parameters) {
-		writer.println("Parameters: ");
-		
-		// We *really* want to get as much information as possible
-		for (Object param : parameters) {
-			writer.println(addPrefix(getStringDescription(param), SECOND_LEVEL_PREFIX));
-		}
-	}
-	
-	/**
-	 * Adds the given prefix to every line in the text.
-	 * @param text - text to modify.
-	 * @param prefix - prefix added to every line in the text.
-	 * @return The modified text.
-	 */
-	protected String addPrefix(String text, String prefix) {
-		return text.replaceAll("(?m)^", prefix);
-	}
-	
-	/**
-	 * Retrieve a string representation of the given object.
-	 * @param value - object to convert.
-	 * @return String representation.
-	 */
-	public static String getStringDescription(Object value) {
-		// We can't only rely on toString.
-		if (value == null) {
-			return "[NULL]";
-		} if (isSimpleType(value) || value instanceof Class<?>) {
-			return value.toString();
-		} else {
-			try {
-				if (!apacheCommonsMissing)
-					return ToStringBuilder.reflectionToString(value, ToStringStyle.MULTI_LINE_STYLE, false, null);
-			} catch (LinkageError ex) {
-				// Apache is probably missing
-				apacheCommonsMissing = true;
-			} catch (ThreadDeath | OutOfMemoryError e) {
-				throw e;
-			} catch (Throwable ex) {
-				// Don't use the error logger to log errors in error logging (that could lead to infinite loops)
-				ProtocolLogger.log(Level.WARNING, "Cannot convert to a String with Apache: " + ex.getMessage());
-			}
-			
-			// Use our custom object printer instead
-			try {
-				return PrettyPrinter.printObject(value, value.getClass(), Object.class);
-			} catch (IllegalAccessException e) {
-				return "[Error: " + e.getMessage() + "]";
-			}
-		}
-	}
-	
-	/**
-	 * Determine if the given object is a wrapper for a primitive/simple type or not.
-	 * @param test - the object to test.
-	 * @return TRUE if this object is simple enough to simply be printed, FALSE othewise.
-	 */
-	protected static boolean isSimpleType(Object test) {
-		return test instanceof String || Primitives.isWrapperType(test.getClass());
-	}
-	
-	/**
-	 * Retrieve the current number of errors printed through {@link #reportDetailed(Object, Report)}.
-	 * @return Number of errors printed.
-	 */
-	public int getErrorCount() {
-		return internalErrorCount.get();
-	}
-
-	/**
-	 * Set the number of errors printed.
-	 * @param errorCount - new number of errors printed.
-	 */
-	public void setErrorCount(int errorCount) {
-		internalErrorCount.set(errorCount);
-	}
-
-	/**
-	 * Retrieve the maximum number of errors we can print before we begin suppressing errors.
-	 * @return Maximum number of errors.
-	 */
-	public int getMaxErrorCount() {
-		return maxErrorCount;
-	}
-
-	/**
-	 * Set the maximum number of errors we can print before we begin suppressing errors.
-	 * @param maxErrorCount - new max count.
-	 */
-	public void setMaxErrorCount(int maxErrorCount) {
-		this.maxErrorCount = maxErrorCount;
-	}
-	
-	/**
-	 * Adds the given global parameter. It will be included in every error report.
-	 * <p>
-	 * Both key and value must be non-null.
-	 * @param key - name of parameter.
-	 * @param value - the global parameter itself.
-	 */
-	public void addGlobalParameter(String key, Object value) {
-		if (key == null)
-			throw new IllegalArgumentException("key cannot be NULL.");
-		if (value == null)
-			throw new IllegalArgumentException("value cannot be NULL.");
-		
-		globalParameters.put(key, value);
-	}
-	
-	/**
-	 * Retrieve a global parameter by its key.
-	 * @param key - key of the parameter to retrieve.
-	 * @return The value of the global parameter, or NULL if not found.
-	 */
-	public Object getGlobalParameter(String key) {
-		if (key == null)
-			throw new IllegalArgumentException("key cannot be NULL.");
-		
-		return globalParameters.get(key);
-	}
-	
-	/**
-	 * Reset all global parameters.
-	 */
-	public void clearGlobalParameters() {
-		globalParameters.clear();
-	}
-	
-	/**
-	 * Retrieve a set of every registered global parameter.
-	 * @return Set of all registered global parameters.
-	 */
-	public Set<String> globalParameters() {
-		return globalParameters.keySet();
-	}
-	
-	/**
-	 * Retrieve the support URL that will be added to all detailed reports.
-	 * @return Support URL.
-	 */
-	public String getSupportURL() {
-		return supportURL;
-	}
-
-	/**
-	 * Set the support URL that will be added to all detailed reports.
-	 * @param supportURL - the new support URL.
-	 */
-	public void setSupportURL(String supportURL) {
-		this.supportURL = supportURL;
-	}
-	
-	/**
-	 * Retrieve the prefix to apply to every line in the error reports.
-	 * @return Error report prefix.
-	 */
-	public String getPrefix() {
-		return prefix;
-	}
-
-	/**
-	 * Set the prefix to apply to every line in the error reports.
-	 * @param prefix - new prefix.
-	 */
-	public void setPrefix(String prefix) {
-		this.prefix = prefix;
-	}
-	
-	/**
-	 * Retrieve the current logger that is used to print all reports.
-	 * @return The current logger.
-	 */
-	public Logger getLogger() {
-		return logger;
-	}
-
-	/**
-	 * Set the current logger that is used to print all reports.
-	 * @param logger - new logger.
-	 */
-	public void setLogger(Logger logger) {
-		this.logger = logger;
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/error/ErrorReporter.java

@@ -1,90 +0,0 @@
-/*
- *  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.error;
-
-import org.bukkit.plugin.Plugin;
-
-import com.comphenix.protocol.error.Report.ReportBuilder;
-
-/**
- * Represents an object that can forward an error {@link Report} to the display and permanent storage.
- * 
- * @author Kristian
- */
-public interface ErrorReporter {
-	/**
-	 * Prints a small minimal error report regarding an exception from another plugin.
-	 * @param sender - the other plugin.
-	 * @param methodName - name of the caller method.
-	 * @param error - the exception itself.
-	 */
-	public abstract void reportMinimal(Plugin sender, String methodName, Throwable error);
-
-	/**
-	 * Prints a small minimal error report regarding an exception from another plugin.
-	 * @param sender - the other plugin.
-	 * @param methodName - name of the caller method.
-	 * @param error - the exception itself.
-	 * @param parameters - any relevant parameters to print.
-	 */
-	public abstract void reportMinimal(Plugin sender, String methodName, Throwable error, Object... parameters);
-	
-	/**
-	 * Prints a debug message from the current sender.
-	 * <p>
-	 * Most users will not see this message.
-	 * @param sender - the sender.
-	 * @param report - the report.
-	 */
-	public abstract void reportDebug(Object sender, Report report);
-	
-	/**
-	 * Prints a debug message from the current sender.
-	 * @param sender - the sender.
-	 * @param builder - the report builder.
-	 */
-	public abstract void reportDebug(Object sender, ReportBuilder builder);
-	
-	/**
-	 * Prints a warning message from the current plugin.
-	 * @param sender - the object containing the caller method.
-	 * @param report - an error report to include.
-	 */
-	public abstract void reportWarning(Object sender, Report report);
-	
-	/**
-	 * Prints a warning message from the current plugin.
-	 * @param sender - the object containing the caller method.
-	 * @param reportBuilder - an error report builder that will be used to get the report.
-	 */
-	public abstract void reportWarning(Object sender, ReportBuilder reportBuilder);
-
-	/**
-	 * Prints a detailed error report about an unhandled exception.
-	 * @param sender - the object containing the caller method.
-	 * @param report - an error report to include.
-	 */
-	public abstract void reportDetailed(Object sender, Report report);
-	
-	/**
-	 * Prints a detailed error report about an unhandled exception.
-	 * @param sender - the object containing the caller method.
-	 * @param reportBuilder - an error report builder that will be used to get the report.
-	 */
-	public abstract void reportDetailed(Object sender, ReportBuilder reportBuilder);
-}

modules/API/src/main/java/com/comphenix/protocol/error/PluginContext.java

@@ -1,108 +0,0 @@
-package com.comphenix.protocol.error;
-
-import java.io.File;
-import java.net.URLDecoder;
-import java.security.CodeSource;
-
-import org.bukkit.Bukkit;
-import org.bukkit.plugin.Plugin;
-
-import com.google.common.base.Preconditions;
-
-public final class PluginContext {
-	// Determine plugin folder
-	private static File pluginFolder;
-	
-	private PluginContext() {
-		// Not constructable
-	}
-	
-	/**
-	 * Retrieve the name of the plugin that called the last method(s) in the exception.
-	 * @param ex - the exception.
-	 * @return The name of the plugin, or NULL.
-	 */
-	public static String getPluginCaller(Exception ex) {
-		StackTraceElement[] elements = ex.getStackTrace();
-		String current = getPluginName(elements[0]);
-		
-		for (int i = 1; i < elements.length; i++) {
-			String caller = getPluginName(elements[i]);
-			if (caller != null && !caller.equals(current)) {
-				return caller;
-			}
-		}
-
-		return null;
-	}
-	
-	/**
-	 * Lookup the plugin that this method invocation belongs to, and return its file name.
-	 * @param element - the method invocation.
-	 * @return Plugin name, or NULL if not found.
-	 */
-	public static String getPluginName(StackTraceElement element) {
-		try {
-			if (Bukkit.getServer() == null) {
-				return null;
-			}
-	
-			CodeSource codeSource = Class.forName(element.getClassName()).getProtectionDomain().getCodeSource();
-			if (codeSource != null) {
-				String encoding = codeSource.getLocation().getPath();
-				File path = new File(URLDecoder.decode(encoding, "UTF-8"));
-				File plugins = getPluginFolder();
-				
-				if (plugins != null && folderContains(plugins, path)) {
-					return path.getName().replaceAll(".jar", "");
-				}
-			}
-		} catch (Throwable ex) {
-			// throw new RuntimeException("Cannot lookup plugin name.", ex);
-		}
-
-		return null; // Cannot find it
-	}
-	
-	/**
-	 * Determine if a folder contains the given file.
-	 * @param folder - the folder.
-	 * @param file - the file.
-	 * @return TRUE if it does, FALSE otherwise.
-	 */
-	private static boolean folderContains(File folder, File file) {
-		Preconditions.checkNotNull(folder, "folder cannot be NULL");
-		Preconditions.checkNotNull(file, "file cannot be NULL");
-		
-		// Get absolute versions
-		folder = folder.getAbsoluteFile();
-		file = file.getAbsoluteFile();
-
-		while (file != null) {
-		    if (folder.equals(file))
-		        return true;
-		    file = file.getParentFile();
-		}
-
-		return false;
-	}
-	
-	/**
-	 * Retrieve the folder that contains every plugin on the server.
-	 * @return Folder with every plugin, or NULL if Bukkit has not been initialized yet.
-	 */
-	private static File getPluginFolder() {
-		File folder = pluginFolder;
-		
-		if (folder == null && Bukkit.getServer() != null) {
-			Plugin[] plugins = Bukkit.getPluginManager().getPlugins();
-			
-			if (plugins.length > 0) {
-				folder = plugins[0].getDataFolder().getParentFile();
-				pluginFolder = folder;
-			}
-		}
-
-		return folder;
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/error/Report.java

@@ -1,240 +0,0 @@
-package com.comphenix.protocol.error;
-
-import java.util.Arrays;
-import java.util.concurrent.TimeUnit;
-
-import javax.annotation.Nullable;
-
-/**
- * Represents a error or warning report.
- * 
- * @author Kristian
- */
-public class Report {
-	private final ReportType type;
-	private final Throwable exception;
-	private final Object[] messageParameters;
-	private final Object[] callerParameters;
-	
-	// Used to rate limit reports that are similar
-	private final long rateLimit;
-	
-	/**
-	 * Must be constructed through the factory method in Report.
-	 */
-	public static class ReportBuilder {
-		private ReportType type;
-		private Throwable exception;
-		private Object[] messageParameters;
-		private Object[] callerParameters;
-		private long rateLimit;
-	
-		private ReportBuilder() {
-			// Don't allow
-		}
-		
-		/**
-		 * Set the current report type. Cannot be NULL.
-		 * @param type - report type.
-		 * @return This builder, for chaining.
-		 */
-		public ReportBuilder type(ReportType type) {
-			if (type == null)
-				throw new IllegalArgumentException("Report type cannot be set to NULL.");
-			this.type = type;
-			return this;
-		}
-		
-		/**
-		 * Set the current exception that occurred.
-		 * @param exception - exception that occurred.
-		 * @return This builder, for chaining.
-		 */
-		public ReportBuilder error(@Nullable Throwable exception) {
-			this.exception = exception;
-			return this;
-		}
-		
-		/**
-		 * Set the message parameters that are used to construct a message text.
-		 * @param messageParameters - parameters for the report type.
-		 * @return This builder, for chaining.
-		 */
-		public ReportBuilder messageParam(@Nullable Object... messageParameters) {
-			this.messageParameters = messageParameters;
-			return this;
-		}
-		
-		/**
-		 * Set the parameters in the caller method. This is optional.
-		 * @param callerParameters - parameters of the caller method.
-		 * @return This builder, for chaining.
-		 */
-		public ReportBuilder callerParam(@Nullable Object... callerParameters) {
-			this.callerParameters = callerParameters;
-			return this;
-		}
-		
-		/**
-		 * Set the minimum number of nanoseconds to wait until a report of equal type and parameters
-		 * is allowed to be printed again.
-		 * @param rateLimit - number of nanoseconds, or 0 to disable. Cannot be negative.
-		 * @return This builder, for chaining.
-		 */
-		public ReportBuilder rateLimit(long rateLimit) {
-			if (rateLimit < 0)
-				throw new IllegalArgumentException("Rate limit cannot be less than zero.");
-			this.rateLimit = rateLimit;
-			return this;
-		}
-		
-		/**
-		 * Set the minimum time to wait until a report of equal type and parameters is allowed to be printed again.
-		 * @param rateLimit - the time, or 0 to disable. Cannot be negative.
-		 * @param rateUnit - the unit of the rate limit.
-		 * @return This builder, for chaining.
-		 */
-		public ReportBuilder rateLimit(long rateLimit, TimeUnit rateUnit) {
-			return rateLimit(TimeUnit.NANOSECONDS.convert(rateLimit, rateUnit));
-		}
-		
-		/**
-		 * Construct a new report with the provided input.
-		 * @return A new report.
-		 */
-		public Report build() {
-			return new Report(type, exception, messageParameters, callerParameters, rateLimit);
-		}
-	}
-	
-	/**
-	 * Construct a new report builder.
-	 * @param type - the initial report type.
-	 * @return Report builder.
-	 */
-	public static ReportBuilder newBuilder(ReportType type) {
-		return new ReportBuilder().type(type);
-	}
-	
-	/**
-	 * Construct a new report with the given type and parameters.
-	 * @param exception - exception that occured in the caller method.
-	 * @param type - the report type that will be used to construct the message.
-	 * @param messageParameters - parameters used to construct the report message.
-	 * @param callerParameters - parameters from the caller method.
-	 */
-	protected Report(ReportType type, @Nullable Throwable exception,
-			@Nullable Object[] messageParameters, @Nullable Object[] callerParameters) {
-		this(type, exception, messageParameters, callerParameters, 0);
-	}
-
-	/**
-	 * Construct a new report with the given type and parameters.
-	 * @param exception - exception that occurred in the caller method.
-	 * @param type - the report type that will be used to construct the message.
-	 * @param messageParameters - parameters used to construct the report message.
-	 * @param callerParameters - parameters from the caller method.
-	 * @param rateLimit - minimum number of nanoseconds to wait until a report of equal type and parameters is allowed to be printed again.
-	 */
-	protected Report(ReportType type, @Nullable Throwable exception,
-			@Nullable Object[] messageParameters, @Nullable Object[] callerParameters, long rateLimit) {
-		if (type == null)
-			throw new IllegalArgumentException("type cannot be NULL.");
-		this.type = type;
-		this.exception = exception;
-		this.messageParameters = messageParameters;
-		this.callerParameters = callerParameters;
-		this.rateLimit = rateLimit;
-	}
-	
-	/**
-	 * Format the current report type with the provided message parameters.
-	 * @return The formated report message.
-	 */
-	public String getReportMessage() {
-		return type.getMessage(messageParameters);
-	}
-	
-	/**
-	 * Retrieve the message parameters that will be used to construc the report message.
-	 * <p>
-	 * This should not be confused with the method parameters of the caller method.
-	 * @return Message parameters.
-	 */
-	public Object[] getMessageParameters() {
-		return messageParameters;
-	}
-	
-	/**
-	 * Retrieve the parameters of the caller method. Optional - may be NULL.
-	 * @return Parameters or the caller method.
-	 */
-	public Object[] getCallerParameters() {
-		return callerParameters;
-	}
-	
-	/**
-	 * Retrieve the report type.
-	 * @return Report type.
-	 */
-	public ReportType getType() {
-		return type;
-	}
-	
-	/**
-	 * Retrieve the associated exception, or NULL if not found.
-	 * @return Associated exception, or NULL.
-	 */
-	public Throwable getException() {
-		return exception;
-	}
-	
-	/**
-	 * Determine if we have any message parameters.
-	 * @return TRUE if there are any message parameters, FALSE otherwise.
-	 */
-	public boolean hasMessageParameters() {
-		return messageParameters != null && messageParameters.length > 0;
-	}
-	
-	/**
-	 * Determine if we have any caller parameters.
-	 * @return TRUE if there are any caller parameters, FALSE otherwise.
-	 */
-	public boolean hasCallerParameters() {
-		return callerParameters != null && callerParameters.length > 0;
-	}
-
-	/**
-	 * Retrieve desired  minimum number of nanoseconds until a report of the same type and parameters should be reprinted.
-	 * <p>
-	 * Note that this may be ignored or modified by the error reporter. Zero indicates no rate limit.
-	 * @return The number of nanoseconds. Never negative.
-	 */
-	public long getRateLimit() {
-		return rateLimit;
-	}
-
-	@Override
-	public int hashCode() {
-		final int prime = 31;
-		int result = 1;
-		result = prime * result + Arrays.hashCode(callerParameters);
-		result = prime * result + Arrays.hashCode(messageParameters);
-		result = prime * result + ((type == null) ? 0 : type.hashCode());
-		return result;
-	}
-
-	@Override
-	public boolean equals(Object obj) {
-		if (this == obj)
-			return true;
-		if (obj instanceof Report) {
-			Report other = (Report) obj;
-			return type == other.type &&
-				   Arrays.equals(callerParameters, other.callerParameters) &&
-				   Arrays.equals(messageParameters, other.messageParameters);
-		}
-		return false;
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/error/ReportType.java

@@ -1,148 +0,0 @@
-package com.comphenix.protocol.error;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
-import java.util.ArrayList;
-import java.util.List;
-
-import com.comphenix.protocol.reflect.FieldAccessException;
-import com.comphenix.protocol.reflect.FuzzyReflection;
-import com.comphenix.protocol.reflect.fuzzy.FuzzyFieldContract;
-
-/**
- * Represents a strongly-typed report. Subclasses should be immutable.
- * <p>
- * By convention, a report must be declared as a static field publicly accessible from the sender class.
- * @author Kristian
- */
-public class ReportType {
-	private final String errorFormat;
-	
-	// Used to store the report name
-	protected String reportName;
-	
-	/**
-	 * Construct a new report type.
-	 * @param errorFormat - string used to format the underlying report.
-	 */
-	public ReportType(String errorFormat) {
-		this.errorFormat = errorFormat;
-	}
-	
-	/**
-	 * Convert the given report to a string, using the provided parameters.
-	 * @param parameters - parameters to insert, or NULL to insert nothing.
-	 * @return The full report in string format.
-	 */
-	public String getMessage(Object[] parameters) {
-		if (parameters == null || parameters.length == 0)
-			return toString();
-		else
-			return String.format(errorFormat, parameters);
-	}
-	
-	@Override
-	public String toString() {
-		return errorFormat;
-	}
-	
-	/**
-	 * Retrieve the class of the given sender.
-	 * <p>
-	 * If the sender is already a Class, we return it.
-	 * @param sender - the sender to look up.
-	 * @return The class of the sender.
-	 */
-	public static Class<?> getSenderClass(Object sender) {
-		if (sender == null)
-			throw new IllegalArgumentException("sender cannot be NUll.");
-		else if (sender instanceof Class<?>)
-			return (Class<?>) sender;
-		else
-			return sender.getClass();
-	}
-	
-	/**
-	 * Retrieve the full canonical name of a given report type.
-	 * <p>
-	 * Note that the sender may be a class (for static callers), in which 
-	 * case it will be used directly instead of its getClass() method.
-	 * <p>
-	 * It is thus not advisable for class classes to report reports.
-	 * @param sender - the sender, or its class.
-	 * @param type - the report type.
-	 * @return The full canonical name.
-	 */
-	public static String getReportName(Object sender, ReportType type) {
-		if (sender == null)
-			throw new IllegalArgumentException("sender cannot be NUll.");
-		return getReportName(getSenderClass(sender), type);
-	}
-	
-	/**
-	 * Retrieve the full canonical name of a given report type.
-	 * <p>
-	 * This is in the format <i>canonical_name_of_class#report_type</i>
-	 * @param clazz - the sender class.
-	 * @param type - the report instance.
-	 * @return The full canonical name.
-	 */
-	private static String getReportName(Class<?> sender, ReportType type) {
-		if (sender == null)
-			throw new IllegalArgumentException("sender cannot be NUll.");
-		
-		// Whether or not we need to retrieve the report name again
-		if (type.reportName == null) {
-			for (Field field : getReportFields(sender)) {
-				try {
-					field.setAccessible(true);
-					
-					if (field.get(null) == type) {
-						// We got the right field!
-						return type.reportName = field.getDeclaringClass().getCanonicalName() + "#" + field.getName();
-					}
-				} catch (IllegalAccessException e) {
-					throw new FieldAccessException("Unable to read field " + field, e);
-				}
-			}
-			throw new IllegalArgumentException("Cannot find report name for " + type);
-		}
-		return type.reportName;
-	}
-	
-	/**
-	 * Retrieve all publicly associated reports.
-	 * @param sender - sender class.
-	 * @return All associated reports.
-	 */
-	public static ReportType[] getReports(Class<?> sender) {
-		if (sender == null)
-			throw new IllegalArgumentException("sender cannot be NULL.");
-		List<ReportType> result = new ArrayList<ReportType>();
-		
-		// Go through all the fields
-		for (Field field : getReportFields(sender)) {
-			try {
-				field.setAccessible(true);
-				result.add((ReportType) field.get(null));
-			} catch (IllegalAccessException e) {
-				throw new FieldAccessException("Unable to read field " + field, e);
-			}
-		}
-		return result.toArray(new ReportType[0]);
-	}
-	
-	/**
-	 * Retrieve all publicly associated report fields.
-	 * @param clazz - sender class.
-	 * @return All associated report fields.
-	 */
-	private static List<Field> getReportFields(Class<?> clazz) {
-		return FuzzyReflection.fromClass(clazz).getFieldList(
-				FuzzyFieldContract.newBuilder().
-					requireModifier(Modifier.STATIC).
-					typeDerivedOf(ReportType.class).
-					build()
-		);
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/error/RethrowErrorReporter.java

@@ -1,53 +0,0 @@
-package com.comphenix.protocol.error;
-
-import org.bukkit.plugin.Plugin;
-
-import com.comphenix.protocol.error.Report.ReportBuilder;
-import com.google.common.base.Joiner;
-
-/**
- * Represents an error reporter that rethrows every exception instead.
- * @author Kristian
- */
-public class RethrowErrorReporter implements ErrorReporter {
-	@Override
-	public void reportMinimal(Plugin sender, String methodName, Throwable error) {
-		throw new RuntimeException("Minimal error by " + sender + " in " + methodName, error);
-	}
-
-	@Override
-	public void reportMinimal(Plugin sender, String methodName, Throwable error, Object... parameters) {
-		throw new RuntimeException(
-				"Minimal error by " + sender + " in " + methodName + " with " + Joiner.on(",").join(parameters), error);
-	}
-
-	@Override
-	public void reportDebug(Object sender, Report report) {
-		// Do nothing - this is just a debug
-	}
-
-	@Override
-	public void reportDebug(Object sender, ReportBuilder builder) {
-		// As above
-	}
-	
-	@Override
-	public void reportWarning(Object sender, ReportBuilder reportBuilder) {
-		reportWarning(sender, reportBuilder.build());
-	}
-	
-	@Override
-	public void reportWarning(Object sender, Report report) {
-		throw new RuntimeException("Warning by " + sender + ": " + report);
-	}
-
-	@Override
-	public void reportDetailed(Object sender, ReportBuilder reportBuilder) {
-		reportDetailed(sender, reportBuilder.build());
-	}
-	
-	@Override
-	public void reportDetailed(Object sender, Report report) {
-		throw new RuntimeException("Detailed error " + sender + ": " + report, report.getException());
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/events/ConnectionSide.java

@@ -1,90 +0,0 @@
-/*
- *  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.events;
-
-import com.comphenix.protocol.PacketType.Sender;
-
-/**
- * Used to set a packet filter.
- * 
- * @author Kristian
- */
-public enum ConnectionSide {
-	/**
-	 * Listen for server side packets that will invoke onPacketSending().
-	 */
-	SERVER_SIDE,
-	
-	/**
-	 * Listen for client side packets that will invoke onPacketReceiving().
-	 */
-	CLIENT_SIDE,
-	
-	/**
-	 * Listen for both client and server side packets.
-	 */
-	BOTH;
-	
-	public boolean isForClient() {
-		return this == CLIENT_SIDE || this == BOTH;
-	}
-	
-	public boolean isForServer() {
-		return this == SERVER_SIDE || this == BOTH;
-	}
-	
-	/**
-	 * Retrieve the sender of this connection side.
-	 * <p>
-	 * This is NULL for {@link #BOTH}.
-	 * @return The sender.
-	 */
-	public Sender getSender() {
-		if (this == SERVER_SIDE)
-			return Sender.SERVER;
-		else if (this == CLIENT_SIDE)
-			return Sender.CLIENT;
-		return null;
-	}
-	
-	/**
-	 * If both connection sides are present, return {@link #BOTH} - otherwise, return the one valud connection side.
-	 * <p>
-	 * NULL is not a valid connection side.
-	 * @param a - the first connection side.
-	 * @param b - the second connection side.
-	 * @return BOTH or the one valid side, or NULL.
-	 */
-	public static ConnectionSide add(ConnectionSide a, ConnectionSide b) {
-		if (a == null)
-			return b;
-		if (b == null)
-			return a;
-		
-		// Now merge them together
-		boolean client = a.isForClient() || b.isForClient();
-		boolean server = a.isForServer() || b.isForServer();
-		
-		if (client && server)
-			return BOTH;
-		else if (client)
-			return CLIENT_SIDE;
-		else
-			return SERVER_SIDE;
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/events/ListenerOptions.java

@@ -1,32 +0,0 @@
-package com.comphenix.protocol.events;
-
-import com.comphenix.protocol.injector.GamePhase;
-
-
-/**
- * Represents additional options a listener may require.
- * 
- * @author Kristian
- */
-public enum ListenerOptions {
-	/**
-	 * Retrieve the serialized client packet as it appears on the network stream.
-	 */
-	INTERCEPT_INPUT_BUFFER,
-	
-	/**
-	 * Disable the automatic game phase detection that will normally force {@link GamePhase#LOGIN} when
-	 * a packet ID is known to be transmitted during login.
-	 */
-	DISABLE_GAMEPHASE_DETECTION,
-	
-	/**
-	 * Do not verify that the owning plugin has a vaid plugin.yml.
-	 */
-	SKIP_PLUGIN_VERIFIER,
-	
-	/**
-	 * Notify ProtocolLib that {@link PacketListener#onPacketSending(PacketEvent)} is thread safe.
-	 */
-	ASYNC;
-}

modules/API/src/main/java/com/comphenix/protocol/events/ListeningWhitelist.java

@@ -1,484 +0,0 @@
-/*
- *  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.events;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.EnumSet;
-import java.util.Set;
-
-import com.comphenix.protocol.PacketType;
-import com.comphenix.protocol.injector.GamePhase;
-import com.comphenix.protocol.injector.packet.PacketRegistry;
-import com.google.common.base.Objects;
-import com.google.common.collect.Sets;
-
-/**
- * Determines which packets will be observed by a listener, and with what priority.
-
- * @author Kristian
- */
-public class ListeningWhitelist {
-	/**
-	 * A whitelist with no packets - indicates that the listener shouldn't observe any packets.
-	 */
-	public static final ListeningWhitelist EMPTY_WHITELIST = new ListeningWhitelist(ListenerPriority.LOW);
-
-	private final ListenerPriority priority;
-	private final GamePhase gamePhase;
-	private final Set<ListenerOptions> options;
-	private final Set<PacketType> types;
-	
-	// Cache whitelist
-	private transient Set<Integer> intWhitelist;
-	
-	private ListeningWhitelist(Builder builder) {
-		this.priority = builder.priority;
-		this.types = builder.types;
-		this.gamePhase = builder.gamePhase;
-		this.options = builder.options;
-	}
-	
-	/**
-	 * Creates a packet whitelist for a given priority with a set of packet IDs.
-	 * <p>
-	 * Deprecated: Use {@link #newBuilder()} instead.
-	 * @param priority - the listener priority.
-	 * @param whitelist - set of IDs to observe/enable.
-	 */
-	@Deprecated
-	public ListeningWhitelist(ListenerPriority priority, Set<Integer> whitelist) {
-		this(priority, whitelist, GamePhase.PLAYING);
-	}
-
-	/**
-	 * Creates a packet whitelist for a given priority with a set of packet IDs.
-	 * <p>
-	 * Deprecated: Use {@link #newBuilder()} instead.
-	 * @param priority - the listener priority.
-	 * @param whitelist - set of IDs to observe/enable.
-	 * @param gamePhase - which game phase to receieve notifications on.
-	 */
-	@Deprecated
-	public ListeningWhitelist(ListenerPriority priority, Set<Integer> whitelist, GamePhase gamePhase) {
-		this.priority = priority;
-		this.types = PacketRegistry.toPacketTypes(safeSet(whitelist));
-		this.gamePhase = gamePhase;
-		this.options = EnumSet.noneOf(ListenerOptions.class);
-	}
-
-	/**
-	 * Creates a packet whitelist of a given priority for a list of packets.
-	 * <p>
-	 * Deprecated: Use {@link #newBuilder()} instead.
-	 * @param priority - the listener priority.
-	 * @param whitelist - list of packet IDs to observe/enable.
-	 */
-	@Deprecated
-	public ListeningWhitelist(ListenerPriority priority, Integer... whitelist) {
-		this.priority = priority;
-		this.types = PacketRegistry.toPacketTypes(Sets.newHashSet(whitelist));
-		this.gamePhase = GamePhase.PLAYING;
-		this.options = EnumSet.noneOf(ListenerOptions.class);
-	}
-
-	/**
-	 * Creates a packet whitelist for a given priority with a set of packet IDs.
-	 * <p>
-	 * Deprecated: Use {@link #newBuilder()} instead.
-	 * @param priority - the listener priority.
-	 * @param whitelist - list of packet IDs to observe/enable.
-	 * @param gamePhase - which game phase to receieve notifications on.
-	 */
-	@Deprecated
-	public ListeningWhitelist(ListenerPriority priority, Integer[] whitelist, GamePhase gamePhase) {
-		this.priority = priority;
-		this.types = PacketRegistry.toPacketTypes(Sets.newHashSet(whitelist));
-		this.gamePhase = gamePhase;
-		this.options = EnumSet.noneOf(ListenerOptions.class);
-	}
-
-	/**
-	 * Creates a packet whitelist for a given priority with a set of packet IDs and options.
-	 * <p>
-	 * Deprecated: Use {@link #newBuilder()} instead.
-	 * @param priority - the listener priority.
-	 * @param whitelist - list of packet IDs to observe/enable.
-	 * @param gamePhase - which game phase to receieve notifications on.
-	 * @param options - every special option associated with this whitelist.
-	 */
-	@Deprecated
-	public ListeningWhitelist(ListenerPriority priority, Integer[] whitelist, GamePhase gamePhase, ListenerOptions... options) {
-		this.priority = priority;
-		this.types = PacketRegistry.toPacketTypes(Sets.newHashSet(whitelist));
-		this.gamePhase = gamePhase;
-		this.options = safeEnumSet(Arrays.asList(options), ListenerOptions.class);
-	}
-
-	/**
-	 * Whether or not this whitelist has any enabled packets.
-	 * @return TRUE if there are any packets, FALSE otherwise.
-	 */
-	public boolean isEnabled() {
-		return types != null && types.size() > 0;
-	}
-
-	/**
-	 * Retrieve the priority in the execution order of the packet listener. Highest priority will be executed last.
-	 * @return Execution order in terms of priority.
-	 */
-	public ListenerPriority getPriority() {
-		return priority;
-	}
-
-	/**
-	 * Retrieves the list of packets that will be observed by the listeners.
-	 * <p>
-	 * Deprecated: Use {@link #getTypes()} instead.
-	 * @return Packet whitelist.
-	 */
-	@Deprecated
-	public Set<Integer> getWhitelist() {
-		if (intWhitelist == null)
-			intWhitelist = PacketRegistry.toLegacy(types);
-		return intWhitelist;
-	}
-
-	/**
-	 * Retrieves a set of the packets that will be observed by the listeners.
-	 * @return Packet whitelist.
-	 */
-	public Set<PacketType> getTypes() {
-		return types;
-	}
-	
-	/**
-	 * Retrieve which game phase this listener is active under.
-	 * @return The active game phase.
-	 */
-	public GamePhase getGamePhase() {
-		return gamePhase;
-	}
-	
-	/**
-	 * Retrieve every special option associated with this whitelist.
-	 * @return Every special option.
-	 */
-	public Set<ListenerOptions> getOptions() {
-		return Collections.unmodifiableSet(options);
-	}
-
-	@Override
-	public int hashCode() {
-		return Objects.hashCode(priority, types, gamePhase, options);
-	}
-
-	/**
-	 * Determine if any of the given IDs can be found in the whitelist.
-	 * @param whitelist - whitelist to test.
-	 * @param idList - list of packet IDs to find.
-	 * @return TRUE if any of the packets in the list can be found in the whitelist, FALSE otherwise.
-	 */
-	public static boolean containsAny(ListeningWhitelist whitelist, int... idList) {
-		if (whitelist != null) {
-			for (int i = 0; i < idList.length; i++) {
-				if (whitelist.getWhitelist().contains(idList[i]))
-					return true;
-			}
-		}
-
-		return false;
-	}
-
-	/**
-	 * Determine if the given whitelist is empty or not.
-	 * @param whitelist - the whitelist to test.
-	 * @return TRUE if the whitelist is empty, FALSE otherwise.
-	 */
-	public static boolean isEmpty(ListeningWhitelist whitelist) {
-		if (whitelist == EMPTY_WHITELIST)
-			return true;
-		else if (whitelist == null)
-			return true;
-		else
-			return whitelist.getTypes().isEmpty();
-	}
-
-	@Override
-	public boolean equals(final Object obj) {
-		if (obj instanceof ListeningWhitelist) {
-			final ListeningWhitelist other = (ListeningWhitelist) obj;
-			return Objects.equal(priority, other.priority)
-					&& Objects.equal(types, other.types)
-					&& Objects.equal(gamePhase, other.gamePhase)
-					&& Objects.equal(options, other.options);
-		} else {
-			return false;
-		}
-	}
-
-	@Override
-	public String toString() {
-		if (this == EMPTY_WHITELIST)
-			return "EMPTY_WHITELIST";
-		else
-			return Objects.toStringHelper(this).
-				add("priority", priority).
-				add("packets", types).
-				add("gamephase", gamePhase).
-				add("options", options).
-				toString();
-	}
-	
-	/**
-	 * Construct a new builder of whitelists.
-	 * @return New whitelist builder.
-	 */
-	public static Builder newBuilder() {
-		return new Builder(null);
-	}
-	
-	/**
-	 * Construct a new builder of whitelists initialized to the same values as the template.
-	 * @param template - the template object.
-	 * @return New whitelist builder.
-	 */
-	public static Builder newBuilder(ListeningWhitelist template) {
-		return new Builder(template);
-	}
-	
-	/**
-	 * Construct a copy of a given enum.
-	 * @param options - the options to copy, or NULL to indicate the empty set.
-	 * @return A copy of the enum set.
-	 */
-	private static <T extends Enum<T>> EnumSet<T> safeEnumSet(Collection<T> options, Class<T> enumClass) {
-		if (options != null && !options.isEmpty()) {
-			return EnumSet.copyOf(options);
-		} else {
-			return EnumSet.noneOf(enumClass);
-		}
-	}
-	
-	/**
-	 * Construct a copy of a given set.
-	 * @param list - the set to copy.
-	 * @return The copied set.
-	 */
-	private static <T> Set<T> safeSet(Collection<T> set) {
-		if (set != null)
-			return Sets.newHashSet(set);
-		else
-			return Collections.emptySet();
-	}
-
-	/**
-	 * Represents a builder of whitelists.
-	 * @author Kristian
-	 */
-	public static class Builder {
-		// Default values
-		private ListenerPriority priority = ListenerPriority.NORMAL;
-		private Set<PacketType> types = Sets.newHashSet();
-		private GamePhase gamePhase = GamePhase.PLAYING;
-		private Set<ListenerOptions> options = Sets.newHashSet();
-		
-		/**
-		 * Construct a new listening whitelist template.
-		 * @param template - the template.
-		 */
-		private Builder(ListeningWhitelist template) {
-			if (template != null) {
-				priority(template.getPriority());
-				gamePhase(template.getGamePhase());
-				types(template.getTypes());
-				options(template.getOptions());
-			}
-		}
-		
-		/**
-		 * Set the priority to use when constructing new whitelists.
-		 * @param priority - the priority.
-		 * @return This builder, for chaining.
-		 */
-		public Builder priority(ListenerPriority priority) {
-			this.priority = priority;
-			return this;
-		}
-		
-		/**
-		 * Set the priority of the whitelist to monitor.
-		 * @return This builder, for chaining.
-		 */
-		public Builder monitor() {
-			return priority(ListenerPriority.MONITOR);
-		}
-		
-		/**
-		 * Set the priority of the whitelist to normal.
-		 * @return This builder, for chaining.
-		 */
-		public Builder normal() {
-			return priority(ListenerPriority.NORMAL);
-		}
-		
-		/**
-		 * Set the priority of the whitelist to lowest.
-		 * @return This builder, for chaining.
-		 */
-		public Builder lowest() {
-			return priority(ListenerPriority.LOWEST);
-		}
-		
-		/**
-		 * Set the priority of the whitelist to low.
-		 * @return This builder, for chaining.
-		 */
-		public Builder low() {
-			return priority(ListenerPriority.LOW);
-		}
-		
-		/**
-		 * Set the priority of the whitelist to highest.
-		 * @return This builder, for chaining.
-		 */
-		public Builder highest() {
-			return priority(ListenerPriority.HIGHEST);
-		}
-		
-		/**
-		 * Set the priority of the whitelist to high.
-		 * @return This builder, for chaining.
-		 */
-		public Builder high() {
-			return priority(ListenerPriority.HIGH);
-		}
-		
-		/**
-		 * Set the whitelist of packet IDs to copy when constructing new whitelists.
-		 * <p>
-		 * Deprecated: Use {@link #types(Collection)} instead.
-		 * @param whitelist - the whitelist of packets.
-		 * @return This builder, for chaining.
-		 */
-		@Deprecated
-		public Builder whitelist(Collection<Integer> whitelist) {
-			this.types = PacketRegistry.toPacketTypes(safeSet(whitelist));
-			return this;
-		}
-		
-		/**
-		 * Set the whitelist of packet types to copy when constructing new whitelists.
-		 * @param types - the whitelist of packets.
-		 * @return This builder, for chaining.
-		 */
-		public Builder types(PacketType... types) {
-			this.types = safeSet(Sets.newHashSet(types));
-			return this;
-		}
-		
-		/**
-		 * Set the whitelist of packet types to copy when constructing new whitelists.
-		 * @param types - the whitelist of packets.
-		 * @return This builder, for chaining.
-		 */
-		public Builder types(Collection<PacketType> types) {
-			this.types = safeSet(types);
-			return this;
-		}
-		
-		/**
-		 * Set the gamephase to use when constructing new whitelists.
-		 * @param gamePhase - the gamephase.
-		 * @return This builder, for chaining.
-		 */
-		public Builder gamePhase(GamePhase gamePhase) {
-			this.gamePhase = gamePhase;
-			return this;
-		}
-		
-		/**
-		 * Set the gamephase to {@link GamePhase#BOTH}.
-		 * @return This builder, for chaining.
-		 */
-		public Builder gamePhaseBoth() {
-			return gamePhase(GamePhase.BOTH);
-		}
-		/**
-		 * Set the options to copy when constructing new whitelists.
-		 * @param options - the options.
-		 * @return This builder, for chaining.
-		 */
-		public Builder options(Set<ListenerOptions> options) {
-			this.options = safeSet(options);
-			return this;
-		}
-		
-		/**
-		 * Set the options to copy when constructing new whitelists.
-		 * @param options - the options.
-		 * @return This builder, for chaining.
-		 */
-		public Builder options(Collection<ListenerOptions> options) {
-			this.options = safeSet(options);
-			return this;
-		}
-		
-		/**
-		 * Set the options to copy when constructing new whitelists.
-		 * @param serverOptions - the options array.
-		 * @return This builder, for chaining.
-		 */
-		public Builder options(ListenerOptions[] serverOptions) {
-			this.options = safeSet(Sets.newHashSet(serverOptions));
-			return this;
-		}
-		
-		/**
-		 * Options to merge into the current set of options.
-		 * @param serverOptions - the options array.
-		 * @return This builder, for chaining.
-		 */
-		public Builder mergeOptions(ListenerOptions... serverOptions) {
-			return mergeOptions(Arrays.asList(serverOptions));
-		}
-		
-		/**
-		 * Options to merge into the current set of options.
-		 * @param serverOptions - the options array.
-		 * @return This builder, for chaining.
-		 */
-		public Builder mergeOptions(Collection<ListenerOptions> serverOptions) {
-			if (options == null)
-				return options(serverOptions);
-			
-			// Merge the options
-			this.options.addAll(serverOptions);
-			return this;
-		}
-		
-		/**
-		 * Construct a new whitelist from the values in this builder.
-		 * @return The new whitelist.
-		 */
-		public ListeningWhitelist build() {
-			return new ListeningWhitelist(this);
-		}
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/events/MonitorAdapter.java

@@ -1,96 +0,0 @@
-/*
- *  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.events;
-
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import org.bukkit.plugin.Plugin;
-
-import com.comphenix.protocol.Packets;
-import com.comphenix.protocol.injector.GamePhase;
-import com.comphenix.protocol.injector.packet.PacketRegistry;
-import com.comphenix.protocol.reflect.FieldAccessException;
-
-/**
- * Represents a listener that is notified of every sent and received packet.
- * 
- * @author Kristian
- */
-public abstract class MonitorAdapter implements PacketListener {
-
-	private Plugin plugin;
-	private ListeningWhitelist sending = ListeningWhitelist.EMPTY_WHITELIST;
-	private ListeningWhitelist receiving = ListeningWhitelist.EMPTY_WHITELIST;
-
-	public MonitorAdapter(Plugin plugin, ConnectionSide side) {
-		initialize(plugin, side, getLogger(plugin));
-	}
-	
-	public MonitorAdapter(Plugin plugin, ConnectionSide side, Logger logger) {
-		initialize(plugin, side, logger);
-	}
-	
-	@SuppressWarnings("deprecation")
-	private void initialize(Plugin plugin, ConnectionSide side, Logger logger) {
-		this.plugin = plugin;
-
-		// Recover in case something goes wrong
-		try {
-			if (side.isForServer())
-				this.sending = ListeningWhitelist.newBuilder().monitor().types(PacketRegistry.getServerPacketTypes()).gamePhaseBoth().build();
-			if (side.isForClient())
-				this.receiving = ListeningWhitelist.newBuilder().monitor().types(PacketRegistry.getClientPacketTypes()).gamePhaseBoth().build();
-		} catch (FieldAccessException e) {
-			if (side.isForServer())
-				this.sending = new ListeningWhitelist(ListenerPriority.MONITOR, Packets.Server.getRegistry().values(), GamePhase.BOTH);
-			if (side.isForClient())
-				this.receiving = new ListeningWhitelist(ListenerPriority.MONITOR, Packets.Client.getRegistry().values(), GamePhase.BOTH);
-			logger.log(Level.WARNING, "Defaulting to 1.3 packets.", e);
-		}
-	}
-	
-	/**
-	 * Retrieve a logger, even if we're running in a CraftBukkit version that doesn't support it.
-	 * @param plugin - the plugin to retrieve.
-	 * @return The logger.
-	 */
-	private Logger getLogger(Plugin plugin) {
-		try {
-			return plugin.getLogger();
-		} catch (NoSuchMethodError e) {
-			return Logger.getLogger("Minecraft");
-		}
-	}
-	
-	@Override
-	public ListeningWhitelist getSendingWhitelist() {
-		return sending;
-	}
-	
-	@Override
-	public ListeningWhitelist getReceivingWhitelist() {
-		return receiving;
-	}
-	
-	@Override
-	public Plugin getPlugin() {
-		return plugin;
-	}
-}
-

modules/API/src/main/java/com/comphenix/protocol/events/NetworkMarker.java

@@ -1,421 +0,0 @@
-package com.comphenix.protocol.events;
-
-import java.io.ByteArrayInputStream;
-import java.io.DataInputStream;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-import java.util.PriorityQueue;
-
-import javax.annotation.Nonnull;
-
-import org.bukkit.entity.Player;
-
-import com.comphenix.protocol.PacketType;
-import com.comphenix.protocol.ProtocolManager;
-import com.comphenix.protocol.utility.ByteBufferInputStream;
-import com.comphenix.protocol.utility.MinecraftReflection;
-import com.comphenix.protocol.utility.StreamSerializer;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.Lists;
-import com.google.common.primitives.Ints;
-
-/**
- * Marker containing the serialized packet data seen from the network,
- * or output handlers that will serialize the current packet.
- * 
- * @author Kristian
- */
-public abstract class NetworkMarker {
-	public static class EmptyBufferMarker extends NetworkMarker {
-		public EmptyBufferMarker(@Nonnull ConnectionSide side) {
-			super(side, (byte[]) null, null);
-		}
-
-		@Override
-		protected DataInputStream skipHeader(DataInputStream input) throws IOException {
-			throw new IllegalStateException("Buffer is empty.");
-		}
-
-		@Override
-		protected ByteBuffer addHeader(ByteBuffer buffer, PacketType type) {
-			throw new IllegalStateException("Buffer is empty.");
-		}
-
-		@Override
-		protected DataInputStream addHeader(DataInputStream input, PacketType type) {
-			throw new IllegalStateException("Buffer is empty.");
-		}
-	}
-	
-	// Custom network handler
-	private PriorityQueue<PacketOutputHandler> outputHandlers;
-	// Post listeners
-	private List<PacketPostListener> postListeners;
-	// Post packets
-	private List<ScheduledPacket> scheduledPackets;
-	
-	// The input buffer
-	private ByteBuffer inputBuffer;
-	private final ConnectionSide side;
-	private final PacketType type;
-	
-	// Cache serializer too
-	private StreamSerializer serializer;
-	
-	/**
-	 * Construct a new network marker.
-	 * @param side - which side this marker belongs to.
-	 * @param inputBuffer - the read serialized packet data.
-	 * @param type - packet type
-	 */
-	public NetworkMarker(@Nonnull ConnectionSide side, ByteBuffer inputBuffer, PacketType type) {
-		this.side = Preconditions.checkNotNull(side, "side cannot be NULL.");
-		this.inputBuffer = inputBuffer;
-		this.type = type;
-	}
-	
-	/**
-	 * Construct a new network marker.
-	 * <p>
-	 * The input buffer is only non-null for client-side packets.
-	 * @param side - which side this marker belongs to.
-	 * @param inputBuffer - the read serialized packet data.
-	 * @param type - packet type
-	 */
-	public NetworkMarker(@Nonnull ConnectionSide side, byte[] inputBuffer, PacketType type) {
-		this.side = Preconditions.checkNotNull(side, "side cannot be NULL.");
-		this.type = type;
-			
-		if (inputBuffer != null) {
-			this.inputBuffer = ByteBuffer.wrap(inputBuffer);
-		}
-	}
-	
-	/**
-	 * Retrieve whether or not this marker belongs to a client or a server side packet.
-	 * @return The side the parent packet belongs to.
-	 */
-	public ConnectionSide getSide() {
-		return side;
-	}
-
-	/**
-	 * Retrieve a utility class for serializing and deserializing Minecraft objects.
-	 * @return Serialization utility class.
-	 */
-	public StreamSerializer getSerializer() {
-		if (serializer == null)
-			serializer = new StreamSerializer();
-		return serializer;
-	}
-	
-	/**
-	 * Retrieve the serialized packet data (excluding the header by default) from the network input stream.
-	 * <p>
-	 * The returned buffer is read-only. If the parent event is a server side packet this
-	 * method throws {@link IllegalStateException}.
-	 * <p>
-	 * It returns NULL if the packet was transmitted by a plugin locally.
-	 * @return A byte buffer containing the raw packet data read from the network.
-	 */
-	public ByteBuffer getInputBuffer() {
-		return getInputBuffer(true);
-	}
-		
-	/**
-	 * Retrieve the serialized packet data from the network input stream.
-	 * <p>
-	 * The returned buffer is read-only. If the parent event is a server side packet this
-	 * method throws {@link IllegalStateException}.
-	 * <p>
-	 * It returns NULL if the packet was transmitted by a plugin locally.
-	 * @param excludeHeader - whether or not to exclude the packet ID header.
-	 * @return A byte buffer containing the raw packet data read from the network.
-	 */
-	public ByteBuffer getInputBuffer(boolean excludeHeader) {
-		if (side.isForServer())
-			throw new IllegalStateException("Server-side packets have no input buffer.");
-		
-		if (inputBuffer != null) {
-			ByteBuffer result = inputBuffer.asReadOnlyBuffer();
-			
-			try {
-				if (excludeHeader)
-					result = skipHeader(result);
-				else
-					result = addHeader(result, type);
-			} catch (IOException e) {
-				throw new RuntimeException("Cannot skip packet header.", e);
-			}
-			return result;
-		}
-		return null;
-	}
-	
-	/**
-	 * Retrieve the serialized packet data (excluding the header by default) as an input stream.
-	 * <p>
-	 * The data is exactly the same as in {@link #getInputBuffer()}.
-	 * @see #getInputBuffer()
-	 * @return The incoming serialized packet data as a stream, or NULL if the packet was transmitted locally.
-	 */
-	public DataInputStream getInputStream() {
-		return getInputStream(true);
-	}
-	
-	/**
-	 * Retrieve the serialized packet data as an input stream.
-	 * <p>
-	 * The data is exactly the same as in {@link #getInputBuffer()}.
-	 * @see #getInputBuffer()
-	 * @param excludeHeader - whether or not to exclude the packet ID header.
-	 * @return The incoming serialized packet data as a stream, or NULL if the packet was transmitted locally.
-	 */
-	@SuppressWarnings("resource")
-	public DataInputStream getInputStream(boolean excludeHeader) {
-		if (side.isForServer())
-			throw new IllegalStateException("Server-side packets have no input buffer.");
-		if (inputBuffer == null)
-			return null;
-		
-		DataInputStream input = new DataInputStream(
-				new ByteArrayInputStream(inputBuffer.array())
-		);
-		
-		try {
-			if (excludeHeader)
-				input = skipHeader(input);
-			else
-				input = addHeader(input, type);
-		} catch (IOException e) {
-			throw new RuntimeException("Cannot skip packet header.", e);
-		}
-		return input;
-	}
-	
-	/**
-	 * Whether or not the output handlers have to write a packet header.
-	 * @return TRUE if they do, FALSE otherwise.
-	 */
-	public boolean requireOutputHeader() {
-		return MinecraftReflection.isUsingNetty();
-	}
-	
-	/**
-	 * Enqueue the given output handler for managing how the current packet will be written to the network stream.
-	 * <p>
-	 * Note that output handlers are not serialized, as most consumers will probably implement them using anonymous classes.
-	 * It is not safe to serialize anonymous classes, as their name depend on the order in which they are declared in the parent class.
-	 * <p>
-	 * This can only be invoked on server side packet events.
-	 * @param handler - the handler that will take part in serializing the packet.
-	 * @return TRUE if it was added, FALSE if it has already been added.
-	 */
-	public boolean addOutputHandler(@Nonnull PacketOutputHandler handler) {
-		checkServerSide();
-		Preconditions.checkNotNull(handler, "handler cannot be NULL.");
-		
-		// Lazy initialization - it's imperative that we save space and time here
-		if (outputHandlers == null) {
-			outputHandlers = new PriorityQueue<PacketOutputHandler>(10, new Comparator<PacketOutputHandler>() {
-				@Override
-				public int compare(PacketOutputHandler o1, PacketOutputHandler o2) {
-					return Ints.compare(o1.getPriority().getSlot(), o2.getPriority().getSlot());
-				}
-			});
-		}
-		return outputHandlers.add(handler);
-	}
-	
-	/**
-	 * Remove a given output handler from the serialization queue.
-	 * <p>
-	 * This can only be invoked on server side packet events.
-	 * @param handler - the handler to remove.
-	 * @return TRUE if the handler was removed, FALSE otherwise.
-	 */
-	public boolean removeOutputHandler(@Nonnull PacketOutputHandler handler) {
-		checkServerSide();
-		Preconditions.checkNotNull(handler, "handler cannot be NULL.");
-		
-		if (outputHandlers != null) {
-			return outputHandlers.remove(handler);
-		}
-		return false;
-	}
-	
-	/**
-	 * Retrieve every registered output handler in no particular order.
-	 * @return Every registered output handler.
-	 */
-	@Nonnull
-	public Collection<PacketOutputHandler> getOutputHandlers() {
-		if (outputHandlers != null) {
-			return outputHandlers;
-		} else {
-			return Collections.emptyList();
-		}
-	}
-	
-	/**
-	 * Add a listener that is invoked after a packet has been successfully sent to the client, or received
-	 * by the server.
-	 * <p>
-	 * Received packets are not guarenteed to have been fully processed, but packets passed
-	 * to {@link ProtocolManager#recieveClientPacket(Player, PacketContainer)} will be processed after the
-	 * current packet event.
-	 * <p>
-	 * Note that post listeners will be executed asynchronously off the main thread. They are not executed
-	 * in any defined order.
-	 * @param listener - the listener that will be invoked.
-	 * @return TRUE if it was added.
-	 */
-	public boolean addPostListener(PacketPostListener listener) {
-		if (postListeners == null)
-			postListeners = Lists.newArrayList();
-		return postListeners.add(listener);
-	}
-	
-	/**
-	 * Remove the first instance of the given listener.
-	 * @param listener - listener to remove.
-	 * @return TRUE if it was removed, FALSE otherwise.
-	 */
-	public boolean removePostListener(PacketPostListener listener) {
-		if (postListeners != null) {
-			return postListeners.remove(listener);
-		}
-		return false;
-	}
-	
-	/**
-	 * Retrieve an immutable view of all the listeners that will be invoked once the packet has been sent or received.
-	 * @return Every post packet listener. Never NULL.
-	 */
-	public List<PacketPostListener> getPostListeners() {
-		return postListeners != null ? Collections.unmodifiableList(postListeners) : Collections.<PacketPostListener>emptyList();
-	}
-	
-	/**
-	 * Retrieve a list of packets that will be schedule (in-order) when the current packet has been successfully transmitted.
-	 * <p>
-	 * This list is modifiable.
-	 * @return List of packets that will be scheduled.
-	 */
-	public List<ScheduledPacket> getScheduledPackets() {
-		if (scheduledPackets == null)
-			scheduledPackets = Lists.newArrayList();
-		return scheduledPackets;
-	}
-	
-	/**
-	 * Ensure that the packet event is server side.
-	 */
-	private void checkServerSide() {
-		if (side.isForClient()) {
-			throw new IllegalStateException("Must be a server side packet.");
-		}
-	}
-	
-	/**
-	 * Return a byte buffer without the header in the current packet.
-	 * <p>
-	 * It's safe to modify the position of the buffer.
-	 * @param buffer - a read-only byte source.
-	 * @return A byte buffer without the header in the current packet.
-	 * @throws IOException If integer reading fails
-	 */
-	protected ByteBuffer skipHeader(ByteBuffer buffer) throws IOException {
-		skipHeader(new DataInputStream(new ByteBufferInputStream(buffer)));
-		return buffer;
-	}
-	
-	/**
-	 * Return an input stream without the header in the current packet.
-	 * <p>
-	 * It's safe to modify the input stream.
-	 * @param input - input stream
-	 * @return An input stream without the header
-	 * @throws IOException If integer reading fails
-	 */
-	protected abstract DataInputStream skipHeader(DataInputStream input) throws IOException;
-	
-	/**
-	 * Return the byte buffer prepended with the packet header.
-	 * @param buffer - the read-only byte buffer.
-	 * @param type - the current packet.
-	 * @return The byte buffer.
-	 */
-	protected abstract ByteBuffer addHeader(ByteBuffer buffer, PacketType type);
-	
-	/**
-	 * Return the input stream prepended with the packet header.
-	 * @param input - the input stream.
-	 * @param type - the current packet.
-	 * @return The byte buffer.
-	 */
-	protected abstract DataInputStream addHeader(DataInputStream input, PacketType type);
-	
-	/**
-	 * Determine if the given marker has any output handlers.
-	 * @param marker - the marker to check.
-	 * @return TRUE if it does, FALSE otherwise.
-	 */
-	public static boolean hasOutputHandlers(NetworkMarker marker) {
-		return marker != null && !marker.getOutputHandlers().isEmpty();
-	}
-	
-	/**
-	 * Determine if the given marker has any post listeners.
-	 * @param marker - the marker to check.
-	 * @return TRUE if it does, FALSE otherwise.
-	 */
-	public static boolean hasPostListeners(NetworkMarker marker) {
-		return marker != null && !marker.getPostListeners().isEmpty();
-	}
-	
-	/**
-	 * Retrieve the byte buffer stored in the given marker.
-	 * @param marker - the marker.
-	 * @return The byte buffer, or NULL if not found.
-	 */
-	public static byte[] getByteBuffer(NetworkMarker marker) {
-		if (marker != null) {
-			ByteBuffer buffer = marker.getInputBuffer();
-			
-			if (buffer != null) {
-				byte[] data = new byte[buffer.remaining()];
-				
-				buffer.get(data, 0, data.length);
-				return data;
-			}
-		}
-		return null;
-	}
-	
-	/**
-	 * Retrieve the network marker of a particular event without creating it.
-	 * <p>
-	 * This is an internal method that should not be used by API users.
-	 * @param event - the event.
-	 * @return The network marker.
-	 */
-	public static NetworkMarker getNetworkMarker(PacketEvent event) {
-		return event.networkMarker;
-	}
-	
-	/**
-	 * Retrieve the scheduled packets of a particular network marker without constructing the list.
-	 * <p>
-	 * This is an internal method that should not be used by API users.
-	 * @param marker - the marker.
-	 * @return The list, or NULL if not found or initialized.
-	 */
-	public static List<ScheduledPacket> readScheduledPackets(NetworkMarker marker) {
-		return marker.scheduledPackets;
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/events/PacketAdapter.java

@@ -1,636 +0,0 @@
-/*
- *  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.events;
-
-import java.util.List;
-import java.util.Set;
-
-import javax.annotation.Nonnull;
-
-import org.bukkit.plugin.Plugin;
-
-import com.comphenix.protocol.PacketType;
-import com.comphenix.protocol.injector.GamePhase;
-import com.comphenix.protocol.injector.packet.PacketRegistry;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Sets;
-
-/**
- * Represents a packet listener with useful constructors.
- * <p>
- * Remember to override onPacketReceiving() and onPacketSending(), depending on the ConnectionSide.
- * @author Kristian
- */
-public abstract class PacketAdapter implements PacketListener {
-	protected Plugin plugin;
-	protected ConnectionSide connectionSide;
-	protected ListeningWhitelist receivingWhitelist = ListeningWhitelist.EMPTY_WHITELIST;
-	protected ListeningWhitelist sendingWhitelist = ListeningWhitelist.EMPTY_WHITELIST;
-
-	/**
-	 * Initialize a packet adapter using a collection of parameters. Use {@link #params()} to get an instance to this builder.
-	 * @param params - the parameters.
-	 */
-	public PacketAdapter(@Nonnull AdapterParameteters params) {
-		this(
-			checkValidity(params).plugin, params.connectionSide, params.listenerPriority,
-			params.gamePhase, params.options, params.packets
-		);
-	}
-	
-	/**
-	 * Initialize a packet listener with the given parameters.
-	 * @param plugin - the plugin.
-	 * @param types - the packet types.
-	 */
-	public PacketAdapter(Plugin plugin, PacketType... types) {
-		this(plugin, ListenerPriority.NORMAL, types);
-	}
-	
-	/**
-	 * Initialize a packet listener with the given parameters.
-	 * @param plugin - the plugin.
-	 * @param types - the packet types.
-	 */
-	public PacketAdapter(Plugin plugin, Iterable<? extends PacketType> types) {
-		this(params(plugin, Iterables.toArray(types, PacketType.class)));
-	}
-	
-	/**
-	 * Initialize a packet listener with the given parameters.
-	 * @param plugin - the plugin.
-	 * @param listenerPriority - the priority.
-	 * @param types - the packet types.
-	 */
-	public PacketAdapter(Plugin plugin, ListenerPriority listenerPriority, Iterable<? extends PacketType> types) {
-		this(params(plugin, Iterables.toArray(types, PacketType.class)).listenerPriority(listenerPriority));
-	}
-	
-	/**
-	 * Initialize a packet listener with the given parameters.
-	 * @param plugin - the plugin.
-	 * @param listenerPriority - the priority.
-	 * @param types - the packet types.
-	 * @param options - the options.
-	 */
-	public PacketAdapter(Plugin plugin, ListenerPriority listenerPriority, Iterable<? extends PacketType> types, ListenerOptions... options) {
-		this(params(plugin, Iterables.toArray(types, PacketType.class)).listenerPriority(listenerPriority).options(options));
-	}
-	
-	/**
-	 * Initialize a packet listener with the given parameters.
-	 * @param plugin - the plugin.
-	 * @param listenerPriority - the priority.
-	 * @param types - the packet types.
-	 */
-	public PacketAdapter(Plugin plugin, ListenerPriority listenerPriority, PacketType... types) {
-		this(params(plugin, types).listenerPriority(listenerPriority));
-	}
-	
-	/**
-	 * Initialize a packet listener with default priority.
-	 * <p>
-	 * Deprecated: Use {@link #params()} instead.
-	 * @param plugin - the plugin that spawned this listener.
-	 * @param connectionSide - the packet type the listener is looking for.
-	 * @param packets - the packet IDs the listener is looking for.
-	 */
-	@Deprecated
-	public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, Integer... packets) {
-		this(plugin, connectionSide, ListenerPriority.NORMAL, packets);
-	}
-	
-	/**
-	 * Initialize a packet listener for a single connection side.
-	 * <p>
-	 * Deprecated: Use {@link #params()} instead.
-	 * @param plugin - the plugin that spawned this listener.
-	 * @param connectionSide - the packet type the listener is looking for.
-	 * @param listenerPriority - the event priority.
-	 * @param packets - the packet IDs the listener is looking for.
-	 */
-	@Deprecated
-	public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, ListenerPriority listenerPriority, Set<Integer> packets) {
-		this(plugin, connectionSide, listenerPriority, GamePhase.PLAYING, packets.toArray(new Integer[0]));
-	}
-	
-	/**
-	 * Initialize a packet listener for a single connection side.
-	 * <p>
-	 * The game phase is used to optimize performance. A listener should only choose BOTH or LOGIN if it's absolutely necessary.
-	 * <p>
-	 * Deprecated: Use {@link #params()} instead.
-	 * @param plugin - the plugin that spawned this listener.
-	 * @param connectionSide - the packet type the listener is looking for.
-	 * @param gamePhase - which game phase this listener is active under.
-	 * @param packets - the packet IDs the listener is looking for.
-	 */
-	@Deprecated
-	public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, GamePhase gamePhase, Set<Integer> packets) {
-		this(plugin, connectionSide, ListenerPriority.NORMAL, gamePhase, packets.toArray(new Integer[0]));
-	}
-	
-	/**
-	 * Initialize a packet listener for a single connection side.
-	 * <p>
-	 * The game phase is used to optimize performance. A listener should only choose BOTH or LOGIN if it's absolutely necessary.
-	 * <p>
-	 * Deprecated: Use {@link #params()} instead.
-	 * @param plugin - the plugin that spawned this listener.
-	 * @param connectionSide - the packet type the listener is looking for.
-	 * @param listenerPriority - the event priority.
-	 * @param gamePhase - which game phase this listener is active under.
-	 * @param packets - the packet IDs the listener is looking for.
-	 */
-	@Deprecated
-	public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, ListenerPriority listenerPriority, GamePhase gamePhase, Set<Integer> packets) {
-		this(plugin, connectionSide, listenerPriority, gamePhase, packets.toArray(new Integer[0]));
-	}
-	
-	/**
-	 * Initialize a packet listener for a single connection side.
-	 * <p>
-	 * Deprecated: Use {@link #params()} instead.
-	 * @param plugin - the plugin that spawned this listener.
-	 * @param connectionSide - the packet type the listener is looking for.
-	 * @param listenerPriority - the event priority.
-	 * @param packets - the packet IDs the listener is looking for.
-	 */
-	@Deprecated
-	public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, ListenerPriority listenerPriority, Integer... packets) {
-		this(plugin, connectionSide, listenerPriority, GamePhase.PLAYING, packets);
-	}
-	
-	/**
-	 * Initialize a packet listener for a single connection side.
-	 * <p>
-	 * Deprecated: Use {@link #params()} instead.
-	 * @param plugin - the plugin that spawned this listener.
-	 * @param connectionSide - the packet type the listener is looking for.
-	 * @param options - which listener options to use.
-	 * @param packets - the packet IDs the listener is looking for.
-	 */
-	@Deprecated
-	public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, ListenerOptions[] options, Integer... packets) {
-		this(plugin, connectionSide, ListenerPriority.NORMAL, GamePhase.PLAYING, options, packets);
-	}
-	
-	/**
-	 * Initialize a packet listener for a single connection side.
-	 * <p>
-	 * Deprecated: Use {@link #params()} instead.
-	 * @param plugin - the plugin that spawned this listener.
-	 * @param connectionSide - the packet type the listener is looking for.
-	 * @param gamePhase - which game phase this listener is active under.
-	 * @param packets - the packet IDs the listener is looking for.
-	 */
-	@Deprecated
-	public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, GamePhase gamePhase, Integer... packets) {
-		this(plugin, connectionSide, ListenerPriority.NORMAL, gamePhase, packets);
-	}
-	
-	/**
-	 * Initialize a packet listener for a single connection side.
-	 * <p>
-	 * The game phase is used to optimize performance. A listener should only choose BOTH or LOGIN if it's absolutely necessary.
-	 * <p>
-	 * Deprecated: Use {@link #params()} instead.
-	 * @param plugin - the plugin that spawned this listener.
-	 * @param connectionSide - the packet type the listener is looking for.
-	 * @param listenerPriority - the event priority.
-	 * @param gamePhase - which game phase this listener is active under.
-	 * @param packets - the packet IDs the listener is looking for.
-	 */
-	@Deprecated
-	public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, ListenerPriority listenerPriority, GamePhase gamePhase, Integer... packets) {
-		this(plugin, connectionSide, listenerPriority, gamePhase, new ListenerOptions[0], packets);
-	}
-	
-	/**
-	 * Initialize a packet listener for a single connection side.
-	 * <p>
-	 * The game phase is used to optimize performance. A listener should only choose BOTH or LOGIN if it's absolutely necessary.
-	 * <p>
-	 * Listener options must be specified in order for {@link NetworkMarker#getInputBuffer()} to function correctly.
-	 * <p>
-	 * Deprecated: Use {@link #params()} instead.
-	 * @param plugin - the plugin that spawned this listener.
-	 * @param connectionSide - the packet type the listener is looking for.
-	 * @param listenerPriority - the event priority.
-	 * @param gamePhase - which game phase this listener is active under.
-	 * @param options - which listener options to use.
-	 * @param packets - the packet IDs the listener is looking for.
-	 */
-	@Deprecated
-	public PacketAdapter(
-			Plugin plugin, ConnectionSide connectionSide, ListenerPriority listenerPriority,
-			GamePhase gamePhase, ListenerOptions[] options, Integer... packets) {
-		
-		this(plugin, connectionSide, listenerPriority, gamePhase, options,
-			PacketRegistry.toPacketTypes(Sets.newHashSet(packets), connectionSide.getSender()).toArray(new PacketType[0])
-		);
-	}
-	
-	// For internal use only
-	private PacketAdapter(
-			Plugin plugin, ConnectionSide connectionSide, ListenerPriority listenerPriority,
-			GamePhase gamePhase, ListenerOptions[] options, PacketType... packets) {
-		
-		if (plugin == null)
-			throw new IllegalArgumentException("plugin cannot be null");
-		if (connectionSide == null)
-			throw new IllegalArgumentException("connectionSide cannot be null");
-		if (listenerPriority == null)
-			throw new IllegalArgumentException("listenerPriority cannot be null");
-		if (gamePhase == null)
-			throw new IllegalArgumentException("gamePhase cannot be NULL");
-		if (packets == null)
-			throw new IllegalArgumentException("packets cannot be null");
-		if (options == null)
-			throw new IllegalArgumentException("options cannot be null");
-		
-		ListenerOptions[] serverOptions = options;
-		ListenerOptions[] clientOptions = options;
-		
-		// Special case that allows us to specify optionIntercept().
-		if (connectionSide == ConnectionSide.BOTH) {
-			serverOptions = except(serverOptions, new ListenerOptions[0],
-					ListenerOptions.INTERCEPT_INPUT_BUFFER);
-		}
-		
-		// Add whitelists
-		if (connectionSide.isForServer())
-			sendingWhitelist = ListeningWhitelist.newBuilder().
-				priority(listenerPriority).
-				types(packets).
-				gamePhase(gamePhase).
-				options(serverOptions).
-				build();
-		
-		if (connectionSide.isForClient())
-			receivingWhitelist = ListeningWhitelist.newBuilder().
-				priority(listenerPriority).
-				types(packets).
-				gamePhase(gamePhase).
-				options(clientOptions).
-				build();
-		
-		this.plugin = plugin;
-		this.connectionSide = connectionSide;
-	}
-	
-	// Remove a given element from an array
-	private static <T> T[] except(T[] values, T[] buffer, T except) {
-		List<T> result = Lists.newArrayList(values);
-		
-		result.remove(except);
-		return result.toArray(buffer);
-	}
-	
-	@Override
-	public void onPacketReceiving(PacketEvent event) {
-		// Lets prevent some bugs
-		throw new IllegalStateException("Override onPacketReceiving to get notifcations of received packets!");
-	}
-	
-	@Override
-	public void onPacketSending(PacketEvent event) {
-		// Lets prevent some bugs
-		throw new IllegalStateException("Override onPacketSending to get notifcations of sent packets!");
-	}
-	
-	@Override
-	public ListeningWhitelist getReceivingWhitelist() {
-		return receivingWhitelist;
-	}
-	
-	@Override
-	public ListeningWhitelist getSendingWhitelist() {
-		return sendingWhitelist;
-	}
-	
-	@Override
-	public Plugin getPlugin() {
-		return plugin;
-	}
-	
-	/**
-	 * Retrieves the name of the plugin that has been associated with the listener.
-	 * @param listener - the listener.
-	 * @return Name of the associated plugin.
-	 */
-	public static String getPluginName(PacketListener listener) {
-		return getPluginName(listener.getPlugin());
-	}
-	
-	/**
-	 * Retrieves the name of the given plugin.
-	 * @param plugin - the plugin.
-	 * @return Name of the given plugin.
-	 */
-	public static String getPluginName(Plugin plugin) {
-		if (plugin == null)
-			return "UNKNOWN";
-
-		try {
-			return plugin.getName();
-		} catch (NoSuchMethodError e) {
-			return plugin.toString();
-		}
-	}
-	
-	@Override
-	public String toString() {
-		// This is used by the error reporter
-		return String.format("PacketAdapter[plugin=%s, sending=%s, receiving=%s]",
-				getPluginName(this),
-				sendingWhitelist,
-				receivingWhitelist);
-	}
-	
-	/**
-	 * Construct a helper object for passing parameters to the packet adapter.
-	 * <p>
-	 * This is often simpler and better than passing them directly to each constructor.
-	 * @return Helper object.
-	 */
-	public static AdapterParameteters params() {
-		return new AdapterParameteters();
-	}
-	
-	/**
-	 * Construct a helper object for passing parameters to the packet adapter.
-	 * <p>
-	 * This is often simpler and better than passing them directly to each constructor.
-	 * Deprecated: Use {@link #params(Plugin, PacketType...)} instead.
-	 * @param plugin - the plugin that spawned this listener.
-	 * @param packets - the packet IDs the listener is looking for.
-	 * @return Helper object.
-	 */
-	@Deprecated
-	public static AdapterParameteters params(Plugin plugin, Integer... packets) {
-		return new AdapterParameteters().plugin(plugin).packets(packets);
-	}
-
-	/**
-	 * Construct a helper object for passing parameters to the packet adapter.
-	 * <p>
-	 * This is often simpler and better than passing them directly to each constructor.
-	 * @param plugin - the plugin that spawned this listener.
-	 * @param packets - the packet types the listener is looking for.
-	 * @return Helper object.
-	 */
-	public static AdapterParameteters params(Plugin plugin, PacketType... packets) {
-		return new AdapterParameteters().plugin(plugin).types(packets);
-	}
-	
-	/**
-	 * Represents a builder for passing parameters to the packet adapter constructor.
-	 * <p>
-	 * Note: Never make spelling mistakes in a public API!
-	 * @author Kristian
-	 */
-	public static class AdapterParameteters {
-		private Plugin plugin;
-		private ConnectionSide connectionSide;
-		private PacketType[] packets;
-	
-		// Parameters with default values
-		private GamePhase gamePhase = GamePhase.PLAYING;
-		private ListenerOptions[] options = new ListenerOptions[0];
-		private ListenerPriority listenerPriority = ListenerPriority.NORMAL;
-		
-		/**
-		 * Set the plugin that spawned this listener. This parameter is required.
-		 * @param plugin - the plugin.
-		 * @return This builder, for chaining.
-		 */
-		public AdapterParameteters plugin(@Nonnull Plugin plugin) {
-			this.plugin = Preconditions.checkNotNull(plugin, "plugin cannot be NULL.");
-			return this;
-		}
-		
-		/**
-		 * Set the packet types this listener is looking for. This parameter is required.
-		 * @param connectionSide - the new packet type.
-		 * @return This builder, for chaining.
-		 */
-		public AdapterParameteters connectionSide(@Nonnull ConnectionSide connectionSide) {
-			this.connectionSide = Preconditions.checkNotNull(connectionSide, "connectionside cannot be NULL.");
-			return this;
-		}
-		
-		/**
-		 * Set this adapter to also look for client-side packets.
-		 * @return This builder, for chaining.
-		 */
-		public AdapterParameteters clientSide() {
-			return connectionSide(ConnectionSide.add(connectionSide, ConnectionSide.CLIENT_SIDE));
-		}
-		
-		/**
-		 * Set this adapter to also look for server-side packets.
-		 * @return This builder, for chaining.
-		 */
-		public AdapterParameteters serverSide() {
-			return connectionSide(ConnectionSide.add(connectionSide, ConnectionSide.SERVER_SIDE));
-		}
-		
-		/**
-		 * Set the the event priority, where the execution is in ascending order from lowest to highest.
-		 * <p>
-		 * Default is {@link ListenerPriority#NORMAL}.
-		 * @param listenerPriority - the new event priority.
-		 * @return This builder, for chaining.
-		 */
-		public AdapterParameteters listenerPriority(@Nonnull ListenerPriority listenerPriority) {
-			this.listenerPriority = Preconditions.checkNotNull(listenerPriority, "listener priority cannot be NULL.");
-			return this;
-		}
-		
-		/**
-		 * Set which game phase this listener is active under. This is a hint for ProtocolLib to start intercepting login packets.
-		 * <p>
-		 * Default is {@link GamePhase#PLAYING}, which will not intercept login packets.
-		 * @param gamePhase - the new game phase.
-		 * @return This builder, for chaining.
-		 */
-		public AdapterParameteters gamePhase(@Nonnull GamePhase gamePhase) {
-			this.gamePhase = Preconditions.checkNotNull(gamePhase, "gamePhase cannot be NULL.");
-			return this;
-		}
-		
-		/**
-		 * Set the game phase to {@link GamePhase#LOGIN}, allowing ProtocolLib to intercept login packets.
-		 * @return This builder, for chaining.
-		 */
-		public AdapterParameteters loginPhase() {
-			return gamePhase(GamePhase.LOGIN);
-		}
-		
-		/**
-		 * Set listener options that decide whether or not to intercept the raw packet data as read from the network stream.
-		 * <p>
-		 * The default is to disable this raw packet interception.
-		 * @param options - every option to use.
-		 * @return This builder, for chaining.
-		 */
-		public AdapterParameteters options(@Nonnull ListenerOptions... options) {
-			this.options = Preconditions.checkNotNull(options, "options cannot be NULL.");
-			return this;
-		}
-
-		/**
-		 * Set listener options that decide whether or not to intercept the raw packet data as read from the network stream.
-		 * <p>
-		 * The default is to disable this raw packet interception.
-		 * @param options - every option to use.
-		 * @return This builder, for chaining.
-		 */
-		public AdapterParameteters options(@Nonnull Set<? extends ListenerOptions> options) {
-			Preconditions.checkNotNull(options, "options cannot be NULL.");
-			this.options = options.toArray(new ListenerOptions[0]);
-			return this;
-		}
-		
-		/**
-		 * Add a given option to the current builder.
-		 * @param option - the option to add.
-		 * @return This builder, for chaining.
-		 */
-		private AdapterParameteters addOption(ListenerOptions option) {
-			if (options == null) {
-				return options(option);
-			} else {
-				Set<ListenerOptions> current = Sets.newHashSet(options);
-				current.add(option);
-				return options(current);
-			}
-		}
-		
-		/**
-		 * Set the listener option to {@link ListenerOptions#INTERCEPT_INPUT_BUFFER}, causing ProtocolLib to read the raw packet data from the network stream.
-		 * @return This builder, for chaining.
-		 */
-		public AdapterParameteters optionIntercept() {
-			return addOption(ListenerOptions.INTERCEPT_INPUT_BUFFER);
-		}
-		
-		/**
-		 * Set the listener option to {@link ListenerOptions#DISABLE_GAMEPHASE_DETECTION}, causing ProtocolLib to ignore automatic game phase detection.
-		 * <p>
-		 * This is no longer relevant in 1.7.2.
-		 * @return This builder, for chaining.
-		 */
-		public AdapterParameteters optionManualGamePhase() {
-			return addOption(ListenerOptions.DISABLE_GAMEPHASE_DETECTION);
-		}
-		
-		/**
-		 * Set the listener option to {@link ListenerOptions#ASYNC}, indicating that our listener is thread safe.
-		 * <p>
-		 * This allows ProtocolLib to perform certain optimizations.
-		 * @return This builder, for chaining.
-		 */
-		public AdapterParameteters optionAsync() {
-			return addOption(ListenerOptions.ASYNC);
-		}
-		
-		/**
-		 * Set the packet IDs of the packets the listener is looking for.
-		 * <p>
-		 * This parameter is required.
-		 * <p>
-		 * Deprecated: Use {@link #types(PacketType...)} instead.
-		 * @param packets - the packet IDs to look for.
-		 * @return This builder, for chaining.
-		 */
-		@Deprecated
-		public AdapterParameteters packets(@Nonnull Integer... packets) {
-			Preconditions.checkNotNull(packets, "packets cannot be NULL");
-			PacketType[] types = new PacketType[packets.length];
-			
-			for (int i = 0; i < types.length; i++) {
-				types[i] = PacketType.findLegacy(packets[i]);
-			}
-			this.packets = types;
-			return this;
-		}
-		
-		/**
-		 * Set the packet IDs of the packets the listener is looking for.
-		 * <p>
-		 * This parameter is required.
-		 * @param packets - a set of the packet IDs to look for.
-		 * @return This builder, for chaining.
-		 */
-		@Deprecated
-		public AdapterParameteters packets(@Nonnull Set<Integer> packets) {
-			return packets(packets.toArray(new Integer[0]));
-		}
-		
-		/**
-		 * Set the packet types the listener is looking for.
-		 * <p>
-		 * This parameter is required.
-		 * @param packets - the packet types to look for.
-		 * @return This builder, for chaining.
-		 */
-		public AdapterParameteters types(@Nonnull PacketType... packets) {
-			// Set the connection side as well
-			if (connectionSide == null) {
-				for (PacketType type : packets) {
-					this.connectionSide = ConnectionSide.add(this.connectionSide, type.getSender().toSide());
-				}
-			}
-			this.packets = Preconditions.checkNotNull(packets, "packets cannot be NULL");
-			
-			if (packets.length == 0)
-				throw new IllegalArgumentException("Passed an empty packet type array.");
-			return this;
-		}
-		
-		/**
-		 * Set the packet types the listener is looking for.
-		 * <p>
-		 * This parameter is required.
-		 * @param packets - a set of packet types to look for.
-		 * @return This builder, for chaining.
-		 */
-		public AdapterParameteters types(@Nonnull Set<PacketType> packets) {
-			return types(packets.toArray(new PacketType[0]));
-		}
-	}
-	
-	/**
-	 * Determine if the required parameters are set.
-	 */
-	private static AdapterParameteters checkValidity(AdapterParameteters params) {
-		if (params == null)
-			throw new IllegalArgumentException("params cannot be NULL.");
-		if (params.plugin == null)
-			throw new IllegalStateException("Plugin was never set in the parameters.");
-		if (params.connectionSide == null)
-			throw new IllegalStateException("Connection side was never set in the parameters.");
-		if (params.packets == null)
-			throw new IllegalStateException("Packet IDs was never set in the parameters.");
-		return params;
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/events/PacketEvent.java

@@ -1,456 +0,0 @@
-/*
- *  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.events;
-
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.lang.ref.WeakReference;
-import java.util.EventObject;
-
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.event.Cancellable;
-
-import com.comphenix.protocol.PacketType;
-import com.comphenix.protocol.ProtocolLibrary;
-import com.comphenix.protocol.async.AsyncMarker;
-import com.comphenix.protocol.error.PluginContext;
-import com.comphenix.protocol.error.Report;
-import com.comphenix.protocol.error.ReportType;
-import com.google.common.base.Objects;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.Multimaps;
-import com.google.common.collect.SetMultimap;
-
-/**
- * Represents a packet sending or receiving event. Changes to the packet will be
- * reflected in the final version to be sent or received. It is also possible to cancel an event.
- * @author Kristian
- */
-public class PacketEvent extends EventObject implements Cancellable {
-	public static final ReportType REPORT_CHANGING_PACKET_TYPE_IS_CONFUSING = new ReportType(
-			"Plugin %s changed packet type from %s to %s in packet listener. This is confusing for other plugins! (Not an error, though!)");
-	
-	private static final SetMultimap<PacketType, PacketType> CHANGE_WARNINGS =
-			Multimaps.synchronizedSetMultimap(HashMultimap.<PacketType, PacketType>create());
-	
-	/**
-	 * Automatically generated by Eclipse.
-	 */
-	private static final long serialVersionUID = -5360289379097430620L;
-	
-	private transient WeakReference<Player> playerReference;
-	private transient Player offlinePlayer;
-	
-	private PacketContainer packet;
-	private boolean serverPacket;
-	private boolean cancel;
-	
-	private AsyncMarker asyncMarker;
-	private boolean asynchronous;
-
-	// Network input and output handlers
-	NetworkMarker networkMarker;
-	
-	// Whether or not a packet event is read only
-	private boolean readOnly;
-	private boolean filtered;
-	
-	/**
-	 * Use the static constructors to create instances of this event.
-	 * @param source - the event source.
-	 */
-	public PacketEvent(Object source) {
-		super(source);
-		this.filtered = true;
-	}
-
-	private PacketEvent(Object source, PacketContainer packet, Player player, boolean serverPacket) {
-		this(source, packet, null, player, serverPacket, true);
-	}
-	
-	private PacketEvent(Object source, PacketContainer packet, NetworkMarker marker, Player player, boolean serverPacket, boolean filtered) {
-		super(source);
-		this.packet = packet;
-		this.playerReference = new WeakReference<Player>(player);
-		this.networkMarker = marker;
-		this.serverPacket = serverPacket;
-		this.filtered = filtered;
-	}
-	
-	private PacketEvent(PacketEvent origial, AsyncMarker asyncMarker) {
-		super(origial.source);
-		this.packet = origial.packet;
-		this.playerReference = origial.playerReference;
-		this.cancel = origial.cancel;
-		this.serverPacket = origial.serverPacket;
-		this.filtered = origial.filtered;
-		this.networkMarker = origial.networkMarker;
-		this.asyncMarker = asyncMarker;
-		this.asynchronous = true;
-	}
-
-	/**
-	 * Creates an event representing a client packet transmission.
-	 * @param source - the event source.
-	 * @param packet - the packet.
-	 * @param client - the client that sent the packet.
-	 * @return The event.
-	 */
-	public static PacketEvent fromClient(Object source, PacketContainer packet, Player client) {
-		return new PacketEvent(source, packet, client, false);
-	}
-	
-	/**
-	 * Creates an event representing a client packet transmission.
-	 * @param source - the event source.
-	 * @param packet - the packet.
-	 * @param marker - the network marker.
-	 * @param client - the client that sent the packet.
-	 * @return The event.
-	 */
-	public static PacketEvent fromClient(Object source, PacketContainer packet, NetworkMarker marker, Player client) {
-		return new PacketEvent(source, packet, marker, client, false, true);
-	}
-	
-	/**
-	 * Creates an event representing a client packet transmission.
-	 * <p>
-	 * If <i>filtered</i> is FALSE, then this event is only processed by packet monitors.
-	 * @param source - the event source.
-	 * @param packet - the packet.
-	 * @param marker - the network marker.
-	 * @param client - the client that sent the packet.
-	 * @param filtered - whether or not this packet event is processed by every packet listener.
-	 * @return The event.
-	 */
-	public static PacketEvent fromClient(Object source, PacketContainer packet, NetworkMarker marker, Player client, boolean filtered) {
-		return new PacketEvent(source, packet, marker, client, false, filtered);
-	}
-	
-	/**
-	 * Creates an event representing a server packet transmission.
-	 * @param source - the event source.
-	 * @param packet - the packet.
-	 * @param recipient - the client that will receieve the packet.
-	 * @return The event.
-	 */
-	public static PacketEvent fromServer(Object source,  PacketContainer packet, Player recipient) {
-		return new PacketEvent(source, packet, recipient, true);
-	}
-	
-	/**
-	 * Creates an event representing a server packet transmission.
-	 * @param source - the event source.
-	 * @param packet - the packet.
-	 * @param marker - the network marker.
-	 * @param recipient - the client that will receieve the packet.
-	 * @return The event.
-	 */
-	public static PacketEvent fromServer(Object source, PacketContainer packet, NetworkMarker marker, Player recipient) {
-		return new PacketEvent(source, packet, marker, recipient, true, true);
-	}
-	
-	/**
-	 * Creates an event representing a server packet transmission.
-	 * <p>
-	 * If <i>filtered</i> is FALSE, then this event is only processed by packet monitors.
-	 * @param source - the event source.
-	 * @param packet - the packet.
-	 * @param marker - the network marker.
-	 * @param recipient - the client that will receieve the packet.
-	 * @param filtered - whether or not this packet event is processed by every packet listener.
-	 * @return The event.
-	 */
-	public static PacketEvent fromServer(Object source, PacketContainer packet, NetworkMarker marker, Player recipient, boolean filtered) {
-		return new PacketEvent(source, packet, marker, recipient, true, filtered);
-	}
-	
-	/**
-	 * Create an asynchronous packet event from a synchronous event and a async marker.
-	 * @param event - the original synchronous event.
-	 * @param marker - the asynchronous marker.
-	 * @return The new packet event.
-	 */
-	public static PacketEvent fromSynchronous(PacketEvent event, AsyncMarker marker) {
-		return new PacketEvent(event, marker);
-	}
-	
-	/**
-	 * Determine if we are executing the packet event in an asynchronous thread.
-	 * <p>
-	 * If so, you must synchronize all calls to the Bukkit API.
-	 * <p>
-	 * Generally, most server packets are executed on the main thread, whereas client packets
-	 * are all executed asynchronously.
-	 * @return TRUE if we are, FALSE otherwise.
-	 */
-	public boolean isAsync() {
-		return !Bukkit.isPrimaryThread();
-	}
-	
-	/**
-	 * Retrieves the packet that will be sent to the player.
-	 * @return Packet to send to the player.
-	 */
-	public PacketContainer getPacket() {
-		return packet;
-	}
-
-	/**
-	 * Replace the packet that will be sent to the player.
-	 * @param packet - the packet that will be sent instead.
-	 */
-	public void setPacket(PacketContainer packet) {
-		if (readOnly)
-			throw new IllegalStateException("The packet event is read-only.");
-		if (packet == null)
-			throw new IllegalArgumentException("Cannot set packet to NULL. Use setCancelled() instead.");
-		
-		// Change warnings
-		final PacketType oldType = this.packet.getType();
-		final PacketType newType = packet.getType();
-		if (this.packet != null && !Objects.equal(oldType, newType)) {
-			// Only report this once
-			if (CHANGE_WARNINGS.put(oldType, newType)) {
-				ProtocolLibrary.getErrorReporter().reportWarning(this,
-						Report.newBuilder(REPORT_CHANGING_PACKET_TYPE_IS_CONFUSING).
-						messageParam(PluginContext.getPluginCaller(new Exception()), oldType, newType).
-						build());
-			}
-		}
-		this.packet = packet;
-	}
-	
-	/**
-	 * Retrieves the packet ID.
-	 * <p>
-	 * Deprecated: Use {@link #getPacketType()} instead.
-	 * @return The current packet ID.
-	 */
-	@Deprecated
-	public int getPacketID() {
-		return packet.getID();
-	}
-	
-	/**
-	 * Retrieve the packet type.
-	 * @return The type.
-	 */
-	public PacketType getPacketType() {
-		return packet.getType();
-	}
-	
-	/**
-	 * Retrieves whether or not the packet should be cancelled.
-	 * @return TRUE if it should be cancelled, FALSE otherwise.
-	 */
-	@Override
-	public boolean isCancelled() {
-		return cancel;
-	}
-	
-	/**
-	 * Retrieve the object responsible for managing the serialized input and output of a packet.
-	 * <p>
-	 * Note that the serialized input data is only available for client-side packets, and the output handlers
-	 * can only be applied to server-side packets.
-	 * @return The network manager.
-	 */
-	public NetworkMarker getNetworkMarker() {
-		if (networkMarker == null) {
-			if (isServerPacket()) {
-				networkMarker = new NetworkMarker.EmptyBufferMarker(
-					serverPacket ? ConnectionSide.SERVER_SIDE : ConnectionSide.CLIENT_SIDE);
-			} else {
-				throw new IllegalStateException("Add the option ListenerOptions.INTERCEPT_INPUT_BUFFER to your listener.");
-			}
-		}
-		return networkMarker;
-	}
-
-	/**
-	 * Update the network manager.
-	 * <p>
-	 * This method is internal - do not call.
-	 * @param networkMarker - the new network manager.
-	 */
-	public void setNetworkMarker(NetworkMarker networkMarker) {
-		this.networkMarker = Preconditions.checkNotNull(networkMarker, "marker cannot be NULL");
-	}
-	
-	/**
-	 * Sets whether or not the packet should be cancelled. Uncancelling is possible.
-	 * <p>
-	 * <b>Warning</b>: A cancelled packet should never be re-transmitted. Use the asynchronous
-	 * packet manager if you need to perform extensive processing. It should also be used
-	 * if you need to synchronize with the main thread.
-	 * <p>
-	 * This ensures that other plugins can work with the same packet.
-	 * <p>
-	 * An asynchronous listener can also delay a packet indefinitely without having to block its thread.
-	 * 
-	 * @param cancel - TRUE if it should be cancelled, FALSE otherwise.
-	 */
-	@Override
-	public void setCancelled(boolean cancel) {
-		if (readOnly)
-			throw new IllegalStateException("The packet event is read-only.");
-		this.cancel = cancel;
-	}
-
-	/**
-	 * Retrieves the player that has sent the packet or is recieving it.
-	 * @return The player associated with this event.
-	 */
-	public Player getPlayer() {
-		return playerReference.get();
-	}
-	
-	/**
-	 * Determine if this packet is filtered by every packet listener.
-	 * <p>
-	 * If not, it will only be intercepted by monitor packets.
-	 * @return TRUE if it is, FALSE otherwise.
-	 */
-	public boolean isFiltered() {
-		return filtered;
-	}
-	
-	/**
-	 * Whether or not this packet was created by the server.
-	 * <p>
-	 * Most listeners can deduce this by noting which listener method was invoked.
-	 * @return TRUE if the packet was created by the server, FALSE if it was created by a client.
-	 */
-	public boolean isServerPacket() {
-		return serverPacket;
-	}
-	
-	/**
-	 * Retrieve the asynchronous marker.
-	 * <p>
-	 * If the packet is synchronous, this marker will be used to schedule an asynchronous event. In the following
-	 * asynchronous event, the marker is used to correctly pass the packet around to the different threads.
-	 * <p>
-	 * Note that if there are no asynchronous events that can receive this packet, the marker is NULL.
-	 * @return The current asynchronous marker, or NULL.
-	 */
-	public AsyncMarker getAsyncMarker() {
-		return asyncMarker;
-	}
-	/**
-	 * Set the asynchronous marker.
-	 * <p>
-	 * If the marker is non-null at the end of an synchronous event processing, the packet will be scheduled
-	 * to be processed asynchronously with the given settings.
-	 * <p>
-	 * Note that if there are no asynchronous events that can receive this packet, the marker should be NULL.
-	 * @param asyncMarker - the new asynchronous marker, or NULL.
-	 * @throws IllegalStateException If the current event is asynchronous.
-	 */
-	public void setAsyncMarker(AsyncMarker asyncMarker) {
-		if (isAsynchronous())
-			throw new IllegalStateException("The marker is immutable for asynchronous events");
-		if (readOnly)
-			throw new IllegalStateException("The packet event is read-only.");
-		this.asyncMarker = asyncMarker;
-	}
-
-	/**
-	 * Determine if the current packet event is read only.
-	 * <p>
-	 * This is used to ensure that a monitor listener doesn't accidentally alter the state of the event. However,
-	 * it is still possible to modify the packet itself, as it would require too many resources to verify its integrity.
-	 * <p>
-	 * Thus, the packet is considered immutable if the packet event is read only.
-	 * @return TRUE if it is, FALSE otherwise.
-	 */
-	public boolean isReadOnly() {
-		return readOnly;
-	}
-	
-	/**
-	 * Set the read-only state of this packet event.
-	 * <p>
-	 * This will be reset for every packet listener.
-	 * @param readOnly - TRUE if it is read-only, FALSE otherwise.
-	 */
-	public void setReadOnly(boolean readOnly) {
-		this.readOnly = readOnly;
-	}
-	
-	/**
-	 * Determine if the packet event has been executed asynchronously or not.
-	 * @return TRUE if this packet event is asynchronous, FALSE otherwise.
-	 */
-	public boolean isAsynchronous() {
-		return asynchronous;
-	}
-
-	/**
-	 * Schedule a packet for sending or receiving after the current packet event is successful.
-	 * <p>
-	 * The packet will be added to {@link NetworkMarker#getScheduledPackets()}.
-	 * @param scheduled - the packet to transmit or receive.
-	 */
-	public void schedule(ScheduledPacket scheduled) {
-		getNetworkMarker().getScheduledPackets().add(scheduled);
-	}
-	
-	/**
-	 * Unschedule a specific packet.
-	 * @param scheduled - the scheduled packet.
-	 * @return TRUE if it was unscheduled, FALSE otherwise.
-	 */
-	public boolean unschedule(ScheduledPacket scheduled) {
-		if (networkMarker != null) {
-			return networkMarker.getScheduledPackets().remove(scheduled);
-		}
-		return false;
-	}
-	
-	private void writeObject(ObjectOutputStream output) throws IOException {
-	    // Default serialization
-		output.defaultWriteObject();
-
-		// Write the name of the player (or NULL if it's not set)
-		output.writeObject(playerReference.get() != null ? new SerializedOfflinePlayer(playerReference.get()) : null);
-	}
-
-	private void readObject(ObjectInputStream input) throws ClassNotFoundException, IOException {
-	    // Default deserialization
-		input.defaultReadObject();
-
-		final SerializedOfflinePlayer serialized = (SerializedOfflinePlayer) input.readObject();
-		
-		// Better than nothing
-	    if (serialized != null) {
-	    	// Store it, to prevent weak reference from cleaning up the reference
-	    	offlinePlayer = serialized.getPlayer();
-	    	playerReference = new WeakReference<Player>(offlinePlayer);
-	    }
-	}
-
-	@Override
-	public String toString() {
-		return "PacketEvent[player=" + getPlayer() + ", packet=" + packet + "]";
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/events/PacketListener.java

@@ -1,71 +0,0 @@
-/*
- *  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.events;
-
-import org.bukkit.plugin.Plugin;
-
-/**
- * Represents a listener that receives notifications when packets are sending or being received.
- * <p>
- * Use {@link PacketAdapter} for a simple wrapper around this interface.
- * @author Kristian
- */
-public interface PacketListener {
-	
-	/**
-	 * Invoked right before a packet is transmitted from the server to the client.
-	 * <p>
-	 * Note that the packet may be replaced, if needed.
-	 * <p>
-	 * This method is executed on the main thread in 1.6.4 and earlier, and thus the Bukkit API is safe to use.
-	 * <p>
-	 * In Minecraft 1.7.2 and later, this method MAY be executed asynchronously, but only if {@link ListenerOptions#ASYNC}
-	 * have been specified in the listener. This is off by default.
-	 * @param event - the packet that should be sent.
-	 */
-	public void onPacketSending(PacketEvent event);
-
-	/**
-	 * Invoked right before a received packet from a client is being processed.
-	 * <p>
-	 * <b>WARNING</b>: <br>
-	 * This method will be called <i>asynchronously</i>! You should synchronize with the main
-	 * thread using {@link org.bukkit.scheduler.BukkitScheduler#scheduleSyncDelayedTask(Plugin, Runnable, long) scheduleSyncDelayedTask}
-	 * if you need to call the Bukkit API.
-	 * @param event - the packet that has been received.
-	 */
-	public void onPacketReceiving(PacketEvent event);
-	
-	/**
-	 * Retrieve which packets sent by the server this listener will observe.
-	 * @return List of server packets to observe, along with the priority.
-	 */
-	public ListeningWhitelist getSendingWhitelist();
-	
-	/**
-	 * Retrieve which packets sent by the client this listener will observe.
-	 * @return List of server packets to observe, along with the priority.
-	 */
-	public ListeningWhitelist getReceivingWhitelist();
-	
-	/**
-	 * Retrieve the plugin that created list packet listener.
-	 * @return The plugin, or NULL if not available.
-	 */
-	public Plugin getPlugin();
-}

modules/API/src/main/java/com/comphenix/protocol/events/PacketOutputAdapter.java

@@ -1,32 +0,0 @@
-package com.comphenix.protocol.events;
-
-import org.bukkit.plugin.Plugin;
-
-/**
- * Represents an adapter version of the output handler interface.
- * @author Kristian
- */
-public abstract class PacketOutputAdapter implements PacketOutputHandler {
-	private final Plugin plugin;
-	private final ListenerPriority priority;
-	
-	/**
-	 * Construct a new packet output adapter with the given values.
-	 * @param priority - the output handler priority.
-	 * @param plugin - the owner plugin.
-	 */
-	public PacketOutputAdapter(Plugin plugin, ListenerPriority priority) {
-		this.priority = priority;
-		this.plugin = plugin;
-	}
-
-	@Override
-	public Plugin getPlugin() {
-		return plugin;
-	}
-	
-	@Override
-	public ListenerPriority getPriority() {
-		return priority;
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/events/PacketOutputHandler.java

@@ -1,37 +0,0 @@
-package com.comphenix.protocol.events;
-
-import org.bukkit.plugin.Plugin;
-
-/**
- * Represents a custom packet serializer onto the network stream.
- * 
- * @author Kristian
- */
-public interface PacketOutputHandler {
-	/**
-	 * Retrieve the priority that decides the order each network handler is allowed to manipulate the output buffer.
-	 * <p>
-	 * Higher priority is executed before lower.
-	 * @return The handler priority.
-	 */
-	public ListenerPriority getPriority();
-	
-	/**
-	 * The plugin that owns this output handler.
-	 * @return The owner plugin.
-	 */
-	public Plugin getPlugin();
-	
-	/**
-	 * Invoked when a given packet is to be written to the output stream.
-	 * <p>
-	 * Note that the buffer is initially filled with the output from the default write method.
-	 * <p>
-	 * In Minecraft 1.6.4, the header is always excluded, whereas it MUST be included in Minecraft 1.7.2. Call 
-	 * {@link NetworkMarker#requireOutputHeader()} to determine this.
-	 * @param event - the packet that will be outputted.
-	 * @param buffer - the data that is currently scheduled to be outputted.
-	 * @return The modified byte array to write. NULL is not permitted.
-	 */
-	public byte[] handle(PacketEvent event, byte[] buffer);
-}

modules/API/src/main/java/com/comphenix/protocol/events/PacketPostListener.java

@@ -1,23 +0,0 @@
-package com.comphenix.protocol.events;
-
-import org.bukkit.plugin.Plugin;
-
-/**
- * Represents a packet listener that is invoked after a packet has been sent or received.
- * @author Kristian
- */
-public interface PacketPostListener {
-	/**
-	 * Retrieve the plugin this listener belongs to.
-	 * @return The assoicated plugin.
-	 */
-	public Plugin getPlugin();
-	
-	/**
-	 * Invoked after a packet has been sent or received.
-	 * <p>
-	 * Note that this is invoked asynchronously.
-	 * @param event - the packet event.
-	 */
-	public void onPostEvent(PacketEvent event);
-}

modules/API/src/main/java/com/comphenix/protocol/events/ScheduledPacket.java

@@ -1,147 +0,0 @@
-package com.comphenix.protocol.events;
-
-import java.lang.reflect.InvocationTargetException;
-
-import org.bukkit.entity.Player;
-
-import com.comphenix.protocol.PacketStream;
-import com.comphenix.protocol.PacketType.Sender;
-import com.comphenix.protocol.ProtocolLibrary;
-import com.google.common.base.Objects;
-import com.google.common.base.Preconditions;
-
-/**
- * Represents a packet that is scheduled for transmission at a later stage.
- * @author Kristian
- */
-public class ScheduledPacket {
-	protected PacketContainer packet;
-	protected Player target;
-	protected boolean filtered;
-	
-	/**
-	 * Construct a new scheduled packet.
-	 * <p>
-	 * Note that the sender is infered from the packet type.
-	 * @param packet - the packet.
-	 * @param target - the target player.
-	 * @param filtered - whether or not to 
-	 */
-	public ScheduledPacket(PacketContainer packet, Player target, boolean filtered) {
-		setPacket(packet);
-		setTarget(target);
-		setFiltered(filtered);
-	}
-	
-	/**
-	 * Construct a new scheduled packet that will not be processed by any packet listeners (except MONITOR).
-	 * @param packet - the packet.
-	 * @param target - the target player.
-	 * @return The scheduled packet.
-	 */
-	public static ScheduledPacket fromSilent(PacketContainer packet, Player target) {
-		return new ScheduledPacket(packet, target, false);
-	}
-
-	/**
-	 * Construct a new scheduled packet that will be processed by any packet listeners.
-	 * @param packet - the packet.
-	 * @param target - the target player.
-	 * @return The scheduled packet.
-	 */
-	public static ScheduledPacket fromFiltered(PacketContainer packet, Player target) {
-		return new ScheduledPacket(packet, target, true);
-	}
-	
-	/**
-	 * Retrieve the packet that will be sent or transmitted.
-	 * @return The sent or received packet.
-	 */
-	public PacketContainer getPacket() {
-		return packet;
-	}
-	
-	/**
-	 * Set the packet that will be sent or transmitted.
-	 * @param packet - the new packet, cannot be NULL.
-	 */
-	public void setPacket(PacketContainer packet) {
-		this.packet = Preconditions.checkNotNull(packet, "packet cannot be NULL");
-	}
-	
-	/**
-	 * Retrieve the target player.
-	 * @return The target player.
-	 */
-	public Player getTarget() {
-		return target;
-	}
-	
-	/**
-	 * Set the target player.
-	 * @param target - the new target, cannot be NULL.
-	 */
-	public void setTarget(Player target) {
-		this.target = Preconditions.checkNotNull(target, "target cannot be NULL");
-	}
-	
-	/**
-	 * Determine if this packet will be processed by any of the packet listeners.
-	 * @return TRUE if it will, FALSE otherwise.
-	 */
-	public boolean isFiltered() {
-		return filtered;
-	}
-	
-	/**
-	 * Set whether or not this packet will be processed by packet listeners (except MONITOR listeners).
-	 * @param filtered - TRUE if it should be processed by listeners, FALSE otherwise.
-	 */
-	public void setFiltered(boolean filtered) {
-		this.filtered = filtered;
-	}
-	
-	/**
-	 * Retrieve the sender of this packet.
-	 * @return The sender.
-	 */
-	public Sender getSender() {
-		return packet.getType().getSender();
-	}
-	
-	/**
-	 * Schedule the packet transmission or reception.
-	 */
-	public void schedule() {
-		schedule(ProtocolLibrary.getProtocolManager());
-	}
-	
-	/**
-	 * Schedule the packet transmission or reception.
-	 * @param stream - the packet stream.
-	 */
-	public void schedule(PacketStream stream) {
-		Preconditions.checkNotNull(stream, "stream cannot be NULL");
-		
-		try {
-			if (getSender() == Sender.CLIENT) {
-				stream.recieveClientPacket(getTarget(), getPacket(), isFiltered());
-			} else {
-				stream.sendServerPacket(getTarget(), getPacket(), isFiltered());
-			}
-		} catch (InvocationTargetException e) {
-			throw new RuntimeException("Cannot send packet " + this + " to " + stream);
-		} catch (IllegalAccessException e) {
-			throw new RuntimeException("Cannot send packet " + this + " to " + stream);
-		}
-	}
-
-	@Override
-	public String toString() {
-		return Objects.toStringHelper(this)
-			.add("packet", packet)
-			.add("target", target)
-			.add("filtered", filtered)
-			.toString();
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/events/SerializedOfflinePlayer.java

@@ -1,243 +0,0 @@
-/*
- *  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.events;
-
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.io.Serializable;
-import java.lang.reflect.Method;
-import java.util.Map;
-import java.util.UUID;
-import java.util.concurrent.ConcurrentHashMap;
-
-import net.sf.cglib.proxy.Enhancer;
-import net.sf.cglib.proxy.MethodInterceptor;
-import net.sf.cglib.proxy.MethodProxy;
-
-import org.bukkit.Bukkit;
-import org.bukkit.Location;
-import org.bukkit.OfflinePlayer;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-
-import com.comphenix.protocol.utility.EnhancerFactory;
-
-/**
- * Represents a player object that can be serialized by Java.
- * 
- * @author Kristian
- */
-class SerializedOfflinePlayer implements OfflinePlayer, Serializable {
-
-	/**
-	 * Generated by Eclipse.
-	 */
-	private static final long serialVersionUID = -2728976288470282810L;
-
-	private transient Location bedSpawnLocation;
-	
-	// Relevant data about an offline player
-	private String name;
-	private UUID uuid;
-	private long firstPlayed;
-	private long lastPlayed;
-	private boolean operator;
-	private boolean banned;
-	private boolean playedBefore;
-	private boolean online;
-	private boolean whitelisted;
-	
-	// Proxy helper
-	private static Map<String, Method> lookup = new ConcurrentHashMap<String, Method>();
-
-	/**
-	 * Constructor used by serialization.
-	 */
-	public SerializedOfflinePlayer() {
-		// Do nothing
-	}
-	
-	/**
-	 * Initialize this serializable offline player from another player.
-	 * @param offline - another player.
-	 */
-	public SerializedOfflinePlayer(OfflinePlayer offline) {
-		this.name = offline.getName();
-		this.uuid = offline.getUniqueId();
-		this.firstPlayed = offline.getFirstPlayed();
-		this.lastPlayed = offline.getLastPlayed();
-		this.operator = offline.isOp();
-		this.banned = offline.isBanned();
-		this.playedBefore = offline.hasPlayedBefore();
-		this.online = offline.isOnline();
-		this.whitelisted = offline.isWhitelisted();
-	}
-	
-	@Override
-	public boolean isOp() {
-		return operator;
-	}
-
-	@Override
-	public void setOp(boolean operator) {
-		this.operator = operator;
-	}
-
-	@Override
-	public Map<String, Object> serialize() {
-		throw new UnsupportedOperationException();
-	}
-
-	@Override
-	public Location getBedSpawnLocation() {
-		return bedSpawnLocation;
-	}
-
-	@Override
-	public long getFirstPlayed() {
-		return firstPlayed;
-	}
-
-	@Override
-	public long getLastPlayed() {
-		return lastPlayed;
-	}
-
-	@Override
-	public UUID getUniqueId() {
-		return uuid;
-	}
-	
-	@Override
-	public String getName() {
-		return name;
-	}
-	
-	@Override
-	public boolean hasPlayedBefore() {
-		return playedBefore;
-	}
-
-	@Override
-	public boolean isBanned() {
-		return banned;
-	}
-
-	@Override
-	public void setBanned(boolean banned) {
-		this.banned = banned;
-	}
-	
-	@Override
-	public boolean isOnline() {
-		return online;
-	}
-
-	@Override
-	public boolean isWhitelisted() {
-		return whitelisted;
-	}
-
-	@Override
-	public void setWhitelisted(boolean whitelisted) {
-		this.whitelisted = whitelisted;
-	}
-
-	private void writeObject(ObjectOutputStream output) throws IOException {
-		output.defaultWriteObject();
-		
-		// Serialize the bed spawn location
-		output.writeUTF(bedSpawnLocation.getWorld().getName());
-		output.writeDouble(bedSpawnLocation.getX());
-		output.writeDouble(bedSpawnLocation.getY());
-		output.writeDouble(bedSpawnLocation.getZ());
-	}
-	
-	private void readObject(ObjectInputStream input) throws ClassNotFoundException, IOException {
-		input.defaultReadObject();
-
-		// Well, this is a problem
-		bedSpawnLocation = new Location(
-				getWorld(input.readUTF()),
-				input.readDouble(),
-				input.readDouble(),
-				input.readDouble()
-		);
-	}
-	
-	private World getWorld(String name) {
-		try {
-			// Try to get the world at least
-			return Bukkit.getServer().getWorld(name);
-		} catch (Exception e) {
-			// Screw it
-			return null;
-		}
-	}
-	
-	@Override
-	public Player getPlayer() {
-		try {
-			// Try to get the real player underneath
-			return Bukkit.getServer().getPlayerExact(name);
-		} catch (Exception e) {
-			return getProxyPlayer();
-		}
-	}
-	
-	/**
-	 * Retrieve a player object that implements OfflinePlayer by refering to this object. 
-	 * <p>
-	 * All other methods cause an exception.
-	 * @return Proxy object.
-	 */
-	public Player getProxyPlayer() {
-		
-		// Remember to initialize the method filter
-		if (lookup.size() == 0) {
-			// Add all public methods
-			for (Method method : OfflinePlayer.class.getMethods()) {
-				lookup.put(method.getName(), method);
-			}
-		}
-		
-    	// MORE CGLIB magic!
-    	Enhancer ex = EnhancerFactory.getInstance().createEnhancer();
-    	ex.setSuperclass(Player.class);
-    	ex.setCallback(new MethodInterceptor() {
-			@Override
-			public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
-				
-				// There's no overloaded methods, so we don't care
-				Method offlineMethod = lookup.get(method.getName());
-				
-				// Ignore all other methods
-				if (offlineMethod == null) {
-					throw new UnsupportedOperationException(
-							"The method " + method.getName() + " is not supported for offline players.");
-				}
-
-				// Invoke our on method
-				return offlineMethod.invoke(SerializedOfflinePlayer.this, args);
-			}
-    	});
-    	
-    	return (Player) ex.create();
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/injector/BukkitUnwrapper.java

@@ -1,282 +0,0 @@
-/*
- *  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.injector;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.Collection;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-
-import com.comphenix.protocol.ProtocolLibrary;
-import com.comphenix.protocol.error.ErrorReporter;
-import com.comphenix.protocol.error.Report;
-import com.comphenix.protocol.error.ReportType;
-import com.comphenix.protocol.injector.PacketConstructor.Unwrapper;
-import com.comphenix.protocol.reflect.FieldUtils;
-import com.comphenix.protocol.reflect.instances.DefaultInstances;
-import com.comphenix.protocol.utility.MinecraftReflection;
-import com.google.common.primitives.Primitives;
-
-/**
- * Represents an object capable of converting wrapped Bukkit objects into NMS objects.
- * <p>
- * Typical conversions include:
- * <ul>
- * <li>org.bukkit.entity.Player to net.minecraft.server.EntityPlayer</li>
- * <li>org.bukkit.World to net.minecraft.server.WorldServer</li>
- * </ul>
- * 
- * @author Kristian
- */
-public class BukkitUnwrapper implements Unwrapper {
-	private static BukkitUnwrapper DEFAULT;
-
-	public static final ReportType REPORT_ILLEGAL_ARGUMENT = new ReportType("Illegal argument.");
-	public static final ReportType REPORT_SECURITY_LIMITATION = new ReportType("Security limitation.");
-	public static final ReportType REPORT_CANNOT_FIND_UNWRAP_METHOD = new ReportType("Cannot find method.");
-	
-	public static final ReportType REPORT_CANNOT_READ_FIELD_HANDLE = new ReportType("Cannot read field 'handle'.");
-	
-	private static Map<Class<?>, Unwrapper> unwrapperCache = new ConcurrentHashMap<Class<?>, Unwrapper>();
-	
-	// The current error reporter
-	private final ErrorReporter reporter;
-	
-	/**
-	 * Retrieve the default instance of the Bukkit unwrapper.
-	 * @return The default instance.
-	 */
-	public static BukkitUnwrapper getInstance() {
-		ErrorReporter currentReporter = ProtocolLibrary.getErrorReporter();
-		
-		// Also recreate the unwrapper if the error reporter has changed
-		if (DEFAULT == null || DEFAULT.reporter != currentReporter) {
-			DEFAULT = new BukkitUnwrapper(currentReporter);
-		}
-		return DEFAULT;
-	}
-	
-	/**
-	 * Construct a new Bukkit unwrapper with ProtocolLib's default error reporter.
-	 */
-	public BukkitUnwrapper() {
-		this(ProtocolLibrary.getErrorReporter());
-	}
-	
-	/**
-	 * Construct a new Bukkit unwrapper with the given error reporter.
-	 * @param reporter - the error reporter to use.
-	 */
-	public BukkitUnwrapper(ErrorReporter reporter) {
-		 this.reporter = reporter;
-	}
-	
-	@SuppressWarnings("unchecked")
-	@Override
-	public Object unwrapItem(Object wrappedObject) {
-		// Special case
-		if (wrappedObject == null)
-			return null;
-		Class<?> currentClass = PacketConstructor.getClass(wrappedObject);
-		
-		// No need to unwrap primitives
-		if (currentClass.isPrimitive() || currentClass.equals(String.class))
-			return null;
-		
-		// Next, check for types that doesn't have a getHandle()
-		if (wrappedObject instanceof Collection) {
-			return handleCollection((Collection<Object>) wrappedObject);
-		} else if (Primitives.isWrapperType(currentClass) || wrappedObject instanceof String) {
-			return null;
-		}
-		
-		Unwrapper specificUnwrapper = getSpecificUnwrapper(currentClass);
-		
-		// Retrieve the handle
-		if (specificUnwrapper != null)
-			return specificUnwrapper.unwrapItem(wrappedObject);
-		else
-			return null;
-	}
-	
-	// Handle a collection of items
-	private Object handleCollection(Collection<Object> wrappedObject) {
-		
-		@SuppressWarnings("unchecked")
-		Collection<Object> copy = DefaultInstances.DEFAULT.getDefault(wrappedObject.getClass());
-		
-		if (copy != null) {
-			// Unwrap every element
-			for (Object element : wrappedObject) {
-				copy.add(unwrapItem(element));
-			}
-			return copy;
-			
-		} else {
-			// Impossible
-			return null;
-		}
-	}
-	
-	/**
-	 * Retrieve a cached class unwrapper for the given class.
-	 * @param type - the type of the class.
-	 * @return An unwrapper for the given class.
-	 */
-	private Unwrapper getSpecificUnwrapper(final Class<?> type) {
-		// See if we're already determined this
-		if (unwrapperCache.containsKey(type)) {
-			// We will never remove from the cache, so this ought to be thread safe
-			return unwrapperCache.get(type);
-		}
-		
-		try {
-			final Method find = type.getMethod("getHandle");
-			
-			// It's thread safe, as getMethod should return the same handle
-			Unwrapper methodUnwrapper = new Unwrapper() {
-				@Override
-				public Object unwrapItem(Object wrappedObject) {
-					try {
-						if (wrappedObject instanceof Class)
-							return checkClass((Class<?>) wrappedObject, type, find.getReturnType());
-						return find.invoke(wrappedObject);
-						
-					} catch (IllegalArgumentException e) {
-						reporter.reportDetailed(this,
-								Report.newBuilder(REPORT_ILLEGAL_ARGUMENT).error(e).callerParam(wrappedObject, find)
-						);
-					} catch (IllegalAccessException e) {
-						// Should not occur either
-						return null;
-					} catch (InvocationTargetException e) {
-						// This is really bad
-						throw new RuntimeException("Minecraft error.", e);
-					}
-					
-					return null;
-				}
-			};
-			
-			unwrapperCache.put(type, methodUnwrapper);
-			return methodUnwrapper;
-			
-		} catch (SecurityException e) {
-			reporter.reportDetailed(this,
-					Report.newBuilder(REPORT_SECURITY_LIMITATION).error(e).callerParam(type)
-			);
-		} catch (NoSuchMethodException e) {
-			// Maybe it's a proxy?
-			Unwrapper proxyUnwrapper = getProxyUnwrapper(type);
-			if (proxyUnwrapper != null)
-				return proxyUnwrapper;
-
-			// Try getting the field unwrapper too
-			Unwrapper fieldUnwrapper = getFieldUnwrapper(type);
-			if (fieldUnwrapper != null)
-				return fieldUnwrapper;
-			else
-				reporter.reportDetailed(this,
-						Report.newBuilder(REPORT_CANNOT_FIND_UNWRAP_METHOD).error(e).callerParam(type));
-		}
-
-		// Default method
-		return null;
-	}
-
-	// Players should /always/ be able to be unwrapped
-	// We should only get here if the 'Player' is a proxy
-	private Unwrapper getProxyUnwrapper(final Class<?> type) {
-		try {
-			if (Player.class.isAssignableFrom(type)) {
-				final Method getHandle = MinecraftReflection.getCraftPlayerClass().getMethod("getHandle");
-
-				Unwrapper unwrapper = new Unwrapper() {
-					@Override
-					public Object unwrapItem(Object wrapped) {
-						try {
-							return getHandle.invoke(((Player) wrapped).getPlayer());
-						} catch (Throwable ex) {
-							try {
-								return getHandle.invoke(Bukkit.getPlayer(((Player) wrapped).getUniqueId()));
-							} catch (ReflectiveOperationException ex1) {
-								throw new RuntimeException("Failed to unwrap proxy " + wrapped, ex);
-							}
-						}
-					}
-				};
-
-				unwrapperCache.put(type, unwrapper);
-				return unwrapper;
-			}
-		} catch (Throwable ignored) {
-		}
-
-		return null;
-	}
-
-	/**
-	 * Retrieve a cached unwrapper using the handle field.
-	 * @param type - a cached field unwrapper.
-	 * @return The cached field unwrapper.
-	 */
-	private Unwrapper getFieldUnwrapper(final Class<?> type) {
-		final Field find = FieldUtils.getField(type, "handle", true);
-		
-		// See if we succeeded
-		if (find != null) {
-			Unwrapper fieldUnwrapper = new Unwrapper() {
-				@Override
-				public Object unwrapItem(Object wrappedObject) {
-					try {
-						if (wrappedObject instanceof Class)
-							return checkClass((Class<?>) wrappedObject, type, find.getType());
-						return FieldUtils.readField(find, wrappedObject, true);
-					} catch (IllegalAccessException e) {
-						reporter.reportDetailed(this,
-								Report.newBuilder(REPORT_CANNOT_READ_FIELD_HANDLE).error(e).callerParam(wrappedObject, find)
-						);
-						return null;
-					}
-				}
-			};
-			
-			unwrapperCache.put(type, fieldUnwrapper);
-			return fieldUnwrapper;
-			
-		} else {
-			// Inform about this too
-			reporter.reportDetailed(this,
-					Report.newBuilder(REPORT_CANNOT_READ_FIELD_HANDLE).callerParam(find)
-			);
-			return null;
-		}
-	}
-
-	private static Class<?> checkClass(Class<?> input, Class<?> expected, Class<?> result) {
-		if (expected.isAssignableFrom(input)) {
-			return result;
-		}
-		return null;
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/injector/GamePhase.java

@@ -1,56 +0,0 @@
-/*
- *  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.injector;
-
-/**
- * The current player phase. This is used to limit the number of different injections.
- * 
- * @author Kristian
- */
-public enum GamePhase {
-	/**
-	 * Only listen for packets sent or received before a player has logged in.
-	 */
-	LOGIN,
-	
-	/**
-	 * Only listen for packets sent or received after a player has logged in.
-	 */
-	PLAYING,
-	
-	/**
-	 * Listen for every sent and received packet.
-	 */
-	BOTH;
-	
-	/**
-	 * Determine if the current value represents the login phase.
-	 * @return TRUE if it does, FALSE otherwise.
-	 */
-	public boolean hasLogin() {
-		return this == LOGIN || this == BOTH;
-	}
-	
-	/**
-	 * Determine if the current value represents the playing phase.
-	 * @return TRUE if it does, FALSE otherwise.
-	 */
-	public boolean hasPlaying() {
-		return this == PLAYING || this == BOTH;
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/injector/PacketConstructor.java

@@ -1,268 +0,0 @@
-/*
- *  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.injector;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.util.List;
-
-import com.comphenix.protocol.PacketType;
-import com.comphenix.protocol.error.RethrowErrorReporter;
-import com.comphenix.protocol.events.PacketContainer;
-import com.comphenix.protocol.injector.packet.PacketRegistry;
-import com.comphenix.protocol.reflect.FieldAccessException;
-import com.comphenix.protocol.wrappers.BukkitConverters;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Lists;
-import com.google.common.primitives.Primitives;
-
-/**
- * A packet constructor that uses an internal Minecraft.
- * @author Kristian
- *
- */
-public class PacketConstructor {
-	/**
-	 * A packet constructor that automatically converts Bukkit types to their NMS conterpart.
-	 * <p>
-	 * Remember to call withPacket().
-	 */
-	public static PacketConstructor DEFAULT = new PacketConstructor(null);
-	
-	// The constructor method that's actually responsible for creating the packet
-	private Constructor<?> constructorMethod;
-	
-	// The packet ID
-	private PacketType type;
-	
-	// Used to unwrap Bukkit objects
-	private List<Unwrapper> unwrappers;
-	
-	// Parameters that need to be unwrapped
-	private Unwrapper[] paramUnwrapper;
-	
-	private PacketConstructor(Constructor<?> constructorMethod) {
-		this.constructorMethod = constructorMethod;
-		this.unwrappers = Lists.newArrayList((Unwrapper) new BukkitUnwrapper(new RethrowErrorReporter() ));
-		this.unwrappers.addAll(BukkitConverters.getUnwrappers());
-	}
-	
-	private PacketConstructor(PacketType type, Constructor<?> constructorMethod, List<Unwrapper> unwrappers, Unwrapper[] paramUnwrapper) {
-		this.type = type;
-		this.constructorMethod = constructorMethod;
-		this.unwrappers = unwrappers;
-		this.paramUnwrapper = paramUnwrapper;
-	}
-	
-	public ImmutableList<Unwrapper> getUnwrappers() {
-		return ImmutableList.copyOf(unwrappers);
-	}
-	
-	/**
-	 * Retrieve the id of the packets this constructor creates.
-	 * <p>
-	 * Deprecated: Use {@link #getType()} instead.
-	 * @return The ID of the packets this constructor will create.
-	 */
-	@Deprecated
-	public int getPacketID() {
-		return type.getLegacyId();
-	}
-	
-	/**
-	 * Retrieve the type of the packets this constructor creates.
-	 * @return The type of the created packets.
-	 */
-	public PacketType getType() {
-		return type;
-	}
-	
-	/**
-	 * Return a copy of the current constructor with a different list of unwrappers.
-	 * @param unwrappers - list of unwrappers that convert Bukkit wrappers into the equivalent NMS classes.
-	 * @return A constructor with a different set of unwrappers.
-	 */
-	public PacketConstructor withUnwrappers(List<Unwrapper> unwrappers) {
-		return new PacketConstructor(type, constructorMethod, unwrappers, paramUnwrapper);
-	}
-
-	/**
-	 * Create a packet constructor that creates packets using the given ID.
-	 * <p>
-	 * Note that if you pass a Class as a value, it will use its type directly.
-	 * <p>
-	 * Deprecated: Use {@link #withPacket(PacketType, Object[])} instead.
-	 * @param id - legacy (1.6.4) packet ID.
-	 * @param values - the values that will match each parameter in the desired constructor.
-	 * @return A packet constructor with these types.
-	 * @throws IllegalArgumentException If no packet constructor could be created with these types.
-	 */
-	@Deprecated
-	public PacketConstructor withPacket(int id, Object[] values) {
-		return withPacket(PacketType.findLegacy(id), values);
-	}
-	
-	/**
-	 * Create a packet constructor that creates packets using the given types.
-	 * <p>
-	 * Note that if you pass a Class as a value, it will use its type directly.
-	 * @param type - the type of the packet to create.
-	 * @param values - the values that will match each parameter in the desired constructor.
-	 * @return A packet constructor with these types.
-	 * @throws IllegalArgumentException If no packet constructor could be created with these types.
-	 */
-	public PacketConstructor withPacket(PacketType type, Object[] values) {
-		Class<?>[] types = new Class<?>[values.length];
-		Throwable lastException = null;
-		Unwrapper[] paramUnwrapper = new Unwrapper[values.length];
-		
-		for (int i = 0; i < types.length; i++) {
-			// Default type
-			if (values[i] != null) {
-				types[i] = PacketConstructor.getClass(values[i]);
-				
-				for (Unwrapper unwrapper : unwrappers) {
-					Object result = null;
-					
-					try {
-						result = unwrapper.unwrapItem(values[i]);
-					} catch (OutOfMemoryError e) {
-						throw e;
-					} catch (ThreadDeath e) {
-						throw e;
-					} catch (Throwable e) {
-						lastException = e;
-					}
-					
-					// Update type we're searching for
-					if (result != null) {
-						types[i] = PacketConstructor.getClass(result);
-						paramUnwrapper[i] = unwrapper;
-						break;
-					}
-				}
-			
-			} else {
-				// Try it
-				types[i] = Object.class;
-			}
-		}
-		Class<?> packetType = PacketRegistry.getPacketClassFromType(type, true);
-		
-		if (packetType == null)
-			throw new IllegalArgumentException("Could not find a packet by the type " + type);
-		
-		// Find the correct constructor
-		for (Constructor<?> constructor : packetType.getConstructors()) {
-			Class<?>[] params = constructor.getParameterTypes();
-
-			if (isCompatible(types, params)) {
-				// Right, we've found our type
-				return new PacketConstructor(type, constructor, unwrappers, paramUnwrapper);
-			}
-		}
-		throw new IllegalArgumentException("No suitable constructor could be found.", lastException);
-	}
-	
-	/**
-	 * Construct a packet using the special builtin Minecraft constructors.
-	 * @param values - values containing Bukkit wrapped items to pass to Minecraft.
-	 * @return The created packet.
-	 * @throws FieldAccessException Failure due to a security limitation.
-	 * @throws IllegalArgumentException Arguments doesn't match the constructor.
-	 * @throws RuntimeException Minecraft threw an exception.
-	 */
-	public PacketContainer createPacket(Object... values) throws FieldAccessException {
-		try {
-			// Convert types that needs to be converted
-			for (int i = 0; i < values.length; i++) {
-				if (paramUnwrapper[i] != null) {
-					values[i] = paramUnwrapper[i].unwrapItem(values[i]);
-				}
-			}
-			
-			Object nmsPacket = constructorMethod.newInstance(values);
-			return new PacketContainer(type, nmsPacket);
-			
-		} catch (IllegalArgumentException e) {
-			throw e;
-		} catch (InstantiationException e) {
-			throw new FieldAccessException("Cannot construct an abstract packet.", e);
-		} catch (IllegalAccessException e) {
-			throw new FieldAccessException("Cannot construct packet due to a security limitation.", e);
-		} catch (InvocationTargetException e) {
-			throw new RuntimeException("Minecraft error.", e);
-		}
-	}
-	
-	// Determine if a method with the types 'params' can be called with 'types'
-	private static boolean isCompatible(Class<?>[] types, Class<?>[] params) {
-		
-		// Determine if the types are similar
-		if (params.length == types.length) {
-			for (int i = 0; i < params.length; i++) {
-				Class<?> inputType = types[i];
-				Class<?> paramType = params[i];
-				
-				// The input type is always wrapped
-				if (!inputType.isPrimitive() && paramType.isPrimitive()) {
-					// Wrap it
-					paramType = Primitives.wrap(paramType);
-				}
-				
-				// Compare assignability
-				if (!paramType.isAssignableFrom(inputType)) {
-					return false;
-				}
-			}
-			
-			return true;
-		}
-		
-		// Parameter count must match
-		return false;
-	}
-	
-	/**
-	 * Retrieve the class of an object, or just the class if it already is a class object.
-	 * @param obj - the object.
-	 * @return The class of an object.
-	 */
-	public static Class<?> getClass(Object obj) {
-		if (obj instanceof Class)
-			return (Class<?>) obj;
-		return obj.getClass();
-	}
-
-	/**
-	 * Represents a unwrapper for a constructor parameter.
-	 * 
-	 * @author Kristian
-	 */
-	public static interface Unwrapper {
-		/**
-		 * Convert the given wrapped object to the equivalent net.minecraft.server object.
-		 * <p>
-		 * Note that we may pass in a class instead of object - in that case, the unwrapper should
-		 * return the equivalent NMS class.
-		 * @param wrappedObject - wrapped object or class.
-		 * @return The equivalent net.minecraft.server object or class.
-		 */
-		public Object unwrapItem(Object wrappedObject);
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/injector/PlayerInjectHooks.java

@@ -1,31 +0,0 @@
-package com.comphenix.protocol.injector;
-
-/**
- * Sets the inject hook type. Different types allow for maximum compatibility.
- * @author Kristian
- */
-public enum PlayerInjectHooks {
-	/**
-	 * The injection hook that does nothing. Set when every other inject hook fails.
-	 */
-	NONE,
-
-	/**
-	 * Override the network handler object itself. Only works in 1.3.
-	 * <p>
-	 * Cannot intercept MapChunk packets.
-	 */
-	NETWORK_MANAGER_OBJECT,
-
-	/**
-	 * Override the packet queue lists in NetworkHandler.
-	 * <p>
-	 * Cannot intercept MapChunk packets.
-	 */
-	NETWORK_HANDLER_FIELDS,
-
-	/**
-	 * Override the server handler object. Versatile, but a tad slower.
-	 */
-	NETWORK_SERVER_OBJECT;
-}

modules/API/src/main/java/com/comphenix/protocol/injector/PlayerLoggedOutException.java

@@ -1,58 +0,0 @@
-/*
- *  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.injector;
-
-/**
- * Invoked when attempting to use a player that has already logged out.
- * 
- * @author Kristian
- */
-public class PlayerLoggedOutException extends RuntimeException {
-
-	/**
-	 * Generated by Eclipse.
-	 */
-	private static final long serialVersionUID = 4889257862160145234L;
-
-	public PlayerLoggedOutException() {
-		// Default error message
-		super("Cannot inject a player that has already logged out.");
-	}
-	
-	public PlayerLoggedOutException(String message, Throwable cause) {
-		super(message, cause);
-	}
-
-	public PlayerLoggedOutException(String message) {
-		super(message);
-	}
-
-	public PlayerLoggedOutException(Throwable cause) {
-		super(cause);
-	}
-	
-	/**
-	 * Construct an exception from a formatted message.
-	 * @param message - the message to format.
-	 * @param params - parameters.
-	 * @return The formated exception
-	 */
-	public static PlayerLoggedOutException fromFormat(String message, Object... params) {
-		return new PlayerLoggedOutException(String.format(message, params));
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/injector/PrioritizedListener.java

@@ -1,81 +0,0 @@
-/*
- *  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.injector;
-
-import com.comphenix.protocol.events.ListenerPriority;
-import com.google.common.base.Objects;
-import com.google.common.primitives.Ints;
-
-/**
- * Represents a listener with a priority.
- * 
- * @author Kristian
- */
-public class PrioritizedListener<TListener> implements Comparable<PrioritizedListener<TListener>> {
-
-	private TListener listener;
-	private ListenerPriority priority;
-	
-	public PrioritizedListener(TListener listener, ListenerPriority priority) {
-		this.listener = listener;
-		this.priority = priority;
-	}
-
-	@Override
-	public int compareTo(PrioritizedListener<TListener> other) {
-		// This ensures that lower priority listeners are executed first
-		return Ints.compare(
-			this.getPriority().getSlot(),
-			other.getPriority().getSlot());
-	}
-	
-	// Note that this equals() method is NOT consistent with compareTo(). 
-	// But, it's a private class so who cares.
-	@SuppressWarnings("unchecked")
-	@Override
-	public boolean equals(Object obj) {
-		// We only care about the listener - priority itself should not make a difference
-	    if(obj instanceof PrioritizedListener){
-	        final PrioritizedListener<TListener> other = (PrioritizedListener<TListener>) obj;
-	        return Objects.equal(listener, other.listener);
-	    } else {
-	        return false;
-	    }
-	}
-	
-	@Override
-	public int hashCode() {
-		return Objects.hashCode(listener);
-	}
-	
-	/**
-	 * Retrieve the underlying listener.
-	 * @return Underlying listener.
-	 */
-	public TListener getListener() {
-		return listener;
-	}
-
-	/**
-	 * Retrieve the priority of this listener.
-	 * @return Listener priority.
-	 */
-	public ListenerPriority getPriority() {
-		return priority;
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/injector/SortedPacketListenerList.java

@@ -1,207 +0,0 @@
-/*
- *  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.injector;
-
-import java.util.Collection;
-
-import com.comphenix.protocol.concurrency.AbstractConcurrentListenerMultimap;
-import com.comphenix.protocol.error.ErrorReporter;
-import com.comphenix.protocol.events.ListenerPriority;
-import com.comphenix.protocol.events.PacketEvent;
-import com.comphenix.protocol.events.PacketListener;
-import com.comphenix.protocol.timing.TimedListenerManager;
-import com.comphenix.protocol.timing.TimedListenerManager.ListenerType;
-import com.comphenix.protocol.timing.TimedTracker;
-
-/**
- * Registry of synchronous packet listeners.
- * 
- * @author Kristian
- */
-public final class SortedPacketListenerList extends AbstractConcurrentListenerMultimap<PacketListener> {
-	// The current listener manager
-	private TimedListenerManager timedManager = TimedListenerManager.getInstance();
-	
-	public SortedPacketListenerList() {
-		super();
-	}
-
-	/**
-	 * Invokes the given packet event for every registered listener.
-	 * @param reporter - the error reporter that will be used to inform about listener exceptions.
-	 * @param event - the packet event to invoke.
-	 */
-	public void invokePacketRecieving(ErrorReporter reporter, PacketEvent event) {
-		Collection<PrioritizedListener<PacketListener>> list = getListener(event.getPacketType());
-		
-		if (list == null)
-			return;
-
-		// The returned list is thread-safe
-		if (timedManager.isTiming()) {
-			for (PrioritizedListener<PacketListener> element : list) {
-				TimedTracker tracker = timedManager.getTracker(element.getListener(), ListenerType.SYNC_CLIENT_SIDE);
-				long token = tracker.beginTracking();
-				
-				// Measure and record the execution time
-				invokeReceivingListener(reporter, event, element);
-				tracker.endTracking(token, event.getPacketType());
-			}
-		} else {
-			for (PrioritizedListener<PacketListener> element : list) {
-				invokeReceivingListener(reporter, event, element);
-			}
-		}
-	}
-	
-	/**
-	 * Invokes the given packet event for every registered listener of the given priority.
-	 * @param reporter - the error reporter that will be used to inform about listener exceptions.
-	 * @param event - the packet event to invoke.
-	 * @param priorityFilter - the required priority for a listener to be invoked.
-	 */
-	public void invokePacketRecieving(ErrorReporter reporter, PacketEvent event, ListenerPriority priorityFilter) {
-		Collection<PrioritizedListener<PacketListener>> list = getListener(event.getPacketType());
-		
-		if (list == null)
-			return;
-
-		// The returned list is thread-safe
-		if (timedManager.isTiming()) {
-			for (PrioritizedListener<PacketListener> element : list) {
-				if (element.getPriority() == priorityFilter) {
-					TimedTracker tracker = timedManager.getTracker(element.getListener(), ListenerType.SYNC_CLIENT_SIDE);
-					long token = tracker.beginTracking();
-					
-					// Measure and record the execution time
-					invokeReceivingListener(reporter, event, element);
-					tracker.endTracking(token, event.getPacketType());
-				}
-			}
-		} else {
-			for (PrioritizedListener<PacketListener> element : list) {
-				if (element.getPriority() == priorityFilter) {
-					invokeReceivingListener(reporter, event, element);
-				}
-			}
-		}
-	}
-	
-	/**
-	 * Invoke a particular receiving listener.
-	 * @param reporter - the error reporter.
-	 * @param event - the related packet event.
-	 * @param element - the listener to invoke.
-	 */
-	private final void invokeReceivingListener(ErrorReporter reporter, PacketEvent event, PrioritizedListener<PacketListener> element) {
-		try {
-			event.setReadOnly(element.getPriority() == ListenerPriority.MONITOR);
-			element.getListener().onPacketReceiving(event);
-			
-		} catch (OutOfMemoryError e) {
-			throw e;
-		} catch (ThreadDeath e) {
-			throw e;
-		} catch (Throwable e) {
-			// Minecraft doesn't want your Exception.
-			reporter.reportMinimal(element.getListener().getPlugin(), "onPacketReceiving(PacketEvent)", e, 
-					event.getPacket().getHandle());
-		}
-	}
-	
-	/**
-	 * Invokes the given packet event for every registered listener.
-	 * @param reporter - the error reporter that will be used to inform about listener exceptions.
-	 * @param event - the packet event to invoke.
-	 */
-	public void invokePacketSending(ErrorReporter reporter, PacketEvent event) {
-		Collection<PrioritizedListener<PacketListener>> list = getListener(event.getPacketType());
-		
-		if (list == null)
-			return;
-		
-		if (timedManager.isTiming()) {
-			for (PrioritizedListener<PacketListener> element : list) {
-				TimedTracker tracker = timedManager.getTracker(element.getListener(), ListenerType.SYNC_SERVER_SIDE);
-				long token = tracker.beginTracking();
-				
-				// Measure and record the execution time
-				invokeSendingListener(reporter, event, element);
-				tracker.endTracking(token, event.getPacketType());
-			}
-		} else {
-			for (PrioritizedListener<PacketListener> element : list) {
-				invokeSendingListener(reporter, event, element);
-			}
-		}
-	}
-	
-	/**
-	 * Invokes the given packet event for every registered listener of the given priority.
-	 * @param reporter - the error reporter that will be used to inform about listener exceptions.
-	 * @param event - the packet event to invoke.
-	 * @param priorityFilter - the required priority for a listener to be invoked.
-	 */
-	public void invokePacketSending(ErrorReporter reporter, PacketEvent event, ListenerPriority priorityFilter) {
-		Collection<PrioritizedListener<PacketListener>> list = getListener(event.getPacketType());
-		
-		if (list == null)
-			return;
-		
-		if (timedManager.isTiming()) {
-			for (PrioritizedListener<PacketListener> element : list) {
-				if (element.getPriority() == priorityFilter) {
-				TimedTracker tracker = timedManager.getTracker(element.getListener(), ListenerType.SYNC_SERVER_SIDE);
-				long token = tracker.beginTracking();
-				
-				// Measure and record the execution time
-				invokeSendingListener(reporter, event, element);
-				tracker.endTracking(token, event.getPacketType());
-				}
-			}
-		} else {
-			for (PrioritizedListener<PacketListener> element : list) {
-				if (element.getPriority() == priorityFilter) {
-					invokeSendingListener(reporter, event, element);
-				}
-			}
-		}
-	}
-	
-	/**
-	 * Invoke a particular sending listener.
-	 * @param reporter - the error reporter.
-	 * @param event - the related packet event.
-	 * @param element - the listener to invoke.
-	 */
-	private final void invokeSendingListener(ErrorReporter reporter, PacketEvent event, PrioritizedListener<PacketListener> element) {
-		try {
-			event.setReadOnly(element.getPriority() == ListenerPriority.MONITOR);
-			element.getListener().onPacketSending(event);
-			
-		} catch (OutOfMemoryError e) {
-			throw e;
-		} catch (ThreadDeath e) {
-			throw e;
-		} catch (Throwable e) {
-			// Minecraft doesn't want your Exception.
-			reporter.reportMinimal(element.getListener().getPlugin(), "onPacketSending(PacketEvent)", e, 
-					event.getPacket().getHandle());
-		}
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/injector/StructureCache.java

@@ -1,175 +0,0 @@
-/*
- *  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.injector;
-
-import java.util.HashSet;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-
-import com.comphenix.protocol.PacketType;
-import com.comphenix.protocol.injector.packet.PacketRegistry;
-import com.comphenix.protocol.reflect.StructureModifier;
-import com.comphenix.protocol.reflect.compiler.BackgroundCompiler;
-import com.comphenix.protocol.reflect.compiler.CompileListener;
-import com.comphenix.protocol.reflect.compiler.CompiledStructureModifier;
-import com.comphenix.protocol.reflect.instances.DefaultInstances;
-import com.comphenix.protocol.utility.MinecraftReflection;
-
-/**
- * Caches structure modifiers.
- * @author Kristian
- */
-public class StructureCache {
-	// Structure modifiers
-	private static ConcurrentMap<PacketType, StructureModifier<Object>> structureModifiers =
-			new ConcurrentHashMap<PacketType, StructureModifier<Object>>();
-
-	private static Set<PacketType> compiling = new HashSet<PacketType>();
-
-	/**
-	 * Creates an empty Minecraft packet of the given id.
-	 * <p>
-	 * Decreated: Use {@link #newPacket(PacketType)} instead.
-	 * @param legacyId - legacy (1.6.4) packet id.
-	 * @return Created packet.
-	 */
-	@Deprecated
-	public static Object newPacket(int legacyId) {
-		return newPacket(PacketType.findLegacy(legacyId));
-	}
-
-	/**
-	 * Creates an empty Minecraft packet of the given type.
-	 * @param type - packet type.
-	 * @return Created packet.
-	 */
-	public static Object newPacket(PacketType type) {
-		Class<?> clazz = PacketRegistry.getPacketClassFromType(type, true);
-
-		// Check the return value
-		if (clazz != null) {
-			// TODO: Optimize DefaultInstances
-			Object result = DefaultInstances.DEFAULT.create(clazz);
-
-			if (result != null) {
-				return result;
-			}
-		}
-		throw new IllegalArgumentException("Cannot find associated packet class: " + type);
-	}
-
-	/**
-	 * Retrieve a cached structure modifier for the given packet id.
-	 * <p>
-	 * Deprecated: Use {@link #getStructure(PacketType)} instead.
-	 * @param legacyId - the legacy (1.6.4) packet ID.
-	 * @return A structure modifier.
-	 */
-	@Deprecated
-	public static StructureModifier<Object> getStructure(int legacyId) {
-		return getStructure(PacketType.findLegacy(legacyId));
-	}
-
-	/**
-	 * Retrieve a cached structure modifier for the given packet type.
-	 * @param type - packet type.
-	 * @return A structure modifier.
-	 */
-	public static StructureModifier<Object> getStructure(PacketType type) {
-		// Compile structures by default
-		return getStructure(type, true);
-	}
-
-	/**
-	 * Retrieve a cached structure modifier given a packet type.
-	 * @param packetType - packet type.
-	 * @return A structure modifier.
-	 */
-	public static StructureModifier<Object> getStructure(Class<?> packetType) {
-		// Compile structures by default
-		return getStructure(packetType, true);
-	}
-
-	/**
-	 * Retrieve a cached structure modifier given a packet type.
-	 * @param packetType - packet type.
-	 * @param compile - whether or not to asynchronously compile the structure modifier.
-	 * @return A structure modifier.
-	 */
-	public static StructureModifier<Object> getStructure(Class<?> packetType, boolean compile) {
-		// Get the ID from the class
-		return getStructure(PacketRegistry.getPacketType(packetType), compile);
-	}
-
-	/**
-	 * Retrieve a cached structure modifier for the given packet ID.
-	 * <p>
-	 * Deprecated: Use {@link #getStructure(PacketType, boolean)} instead.
-	 * @param legacyId - the legacy (1.6.4) packet ID.
-	 * @param compile - whether or not to asynchronously compile the structure modifier.
-	 * @return A structure modifier.
-	 */
-	@Deprecated
-	public static StructureModifier<Object> getStructure(final int legacyId, boolean compile) {
-		return getStructure(PacketType.findLegacy(legacyId), compile);
-	}
-
-	/**
-	 * Retrieve a cached structure modifier for the given packet type.
-	 * @param type - packet type.
-	 * @param compile - whether or not to asynchronously compile the structure modifier.
-	 * @return A structure modifier.
-	 */
-	public static StructureModifier<Object> getStructure(final PacketType type, boolean compile) {
-		StructureModifier<Object> result = structureModifiers.get(type);
-
-		// We don't want to create this for every lookup
-		if (result == null) {
-			// Use the vanilla class definition
-			final StructureModifier<Object> value = new StructureModifier<Object>(
-					PacketRegistry.getPacketClassFromType(type, true), MinecraftReflection.getPacketClass(), true);
-
-			result = structureModifiers.putIfAbsent(type, value);
-
-			// We may end up creating multiple modifiers, but we'll agree on which to use
-			if (result == null) {
-				result = value;
-			}
-		}
-
-		// Automatically compile the structure modifier
-		if (compile && !(result instanceof CompiledStructureModifier)) {
-			// Compilation is many orders of magnitude slower than synchronization
-			synchronized (compiling) {
-				final BackgroundCompiler compiler = BackgroundCompiler.getInstance();
-
-				if (!compiling.contains(type) && compiler != null) {
-					compiler.scheduleCompilation(result, new CompileListener<Object>() {
-						@Override
-						public void onCompiled(StructureModifier<Object> compiledModifier) {
-							structureModifiers.put(type, compiledModifier);
-						}
-					});
-					compiling.add(type);
-				}
-			}
-		}
-		return result;
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/injector/netty/NettyByteBufAdapter.java

@@ -1,392 +0,0 @@
-/**
- *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
- *  Copyright (C) 2015 dmulloy2
- *
- *  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.injector.netty;
-
-import io.netty.buffer.AbstractByteBuf;
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.ByteBufAllocator;
-
-import java.io.DataInputStream;
-import java.io.DataOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-import java.nio.channels.Channels;
-import java.nio.channels.GatheringByteChannel;
-import java.nio.channels.ScatteringByteChannel;
-import java.nio.channels.WritableByteChannel;
-
-import com.comphenix.protocol.reflect.accessors.Accessors;
-import com.comphenix.protocol.reflect.accessors.FieldAccessor;
-import com.comphenix.protocol.utility.MinecraftReflection;
-import com.google.common.io.ByteStreams;
-
-/**
- * Construct a ByteBuf around an input stream and an output stream.
- * <p>
- * Note that as streams usually don't support seeking, this implementation will ignore
- * all indexing in the byte buffer.
- * @author Kristian
- */
-public class NettyByteBufAdapter extends AbstractByteBuf {
-	private DataInputStream input;
-	private DataOutputStream output;
-	
-	// For modifying the reader or writer index
-	private static FieldAccessor READER_INDEX;
-	private static FieldAccessor WRITER_INDEX;
-	
-	private static final int CAPACITY = Short.MAX_VALUE;
-	
-	private NettyByteBufAdapter(DataInputStream input, DataOutputStream output) {
-		// Just pick a figure
-		super(CAPACITY);
-		this.input = input;
-		this.output = output;
-		
-		// Prepare accessors
-		try {
-			if (READER_INDEX == null) {
-				READER_INDEX = Accessors.getFieldAccessor(AbstractByteBuf.class.getDeclaredField("readerIndex"));
-			}
-			if (WRITER_INDEX == null) {
-				WRITER_INDEX = Accessors.getFieldAccessor(AbstractByteBuf.class.getDeclaredField("writerIndex"));
-			}
-		} catch (Exception e) {
-			throw new RuntimeException("Cannot initialize ByteBufAdapter.", e);
-		}
-		
-		// "Infinite" reading/writing
-		if (input == null)
-			READER_INDEX.set(this, Integer.MAX_VALUE);
-		if (output == null)
-			WRITER_INDEX.set(this, Integer.MAX_VALUE);
-	}
-
-	/**
-	 * Construct a new Minecraft packet serializer using the current byte buf adapter.
-	 * @param input - the input stream.
-	 * @return A packet serializer with a wrapped byte buf adapter.
-	 */
-	public static ByteBuf packetReader(DataInputStream input) {
-		return (ByteBuf) MinecraftReflection.getPacketDataSerializer(new NettyByteBufAdapter(input, null));
-	}
-	
-	/**
-	 * Construct a new Minecraft packet deserializer using the current byte buf adapter.
-	 * @param output - the output stream.
-	 * @return A packet serializer with a wrapped byte buf adapter.
-	 */
-	public static ByteBuf packetWriter(DataOutputStream output) {
-		return (ByteBuf) MinecraftReflection.getPacketDataSerializer(new NettyByteBufAdapter(null, output));
-	}
-	
-	@Override
-	public int refCnt() {
-		return 1;
-	}
-
-	@Override
-	public boolean release() {
-		return false;
-	}
-
-	@Override
-	public boolean release(int paramInt) {
-		return false;
-	}
-
-	@Override
-	protected byte _getByte(int paramInt) {
-		try {
-			return input.readByte();
-		} catch (IOException e) {
-			throw new RuntimeException("Cannot read input.", e);
-		}
-	}
-
-	@Override
-	protected short _getShort(int paramInt) {
-		try {
-			return input.readShort();
-		} catch (IOException e) {
-			throw new RuntimeException("Cannot read input.", e);
-		}
-	}
-
-	@Override
-	protected int _getUnsignedMedium(int paramInt) {
-		try {
-			return input.readUnsignedShort();
-		} catch (IOException e) {
-			throw new RuntimeException("Cannot read input.", e);
-		}
-	}
-
-	@Override
-	protected int _getInt(int paramInt) {
-		try {
-			return input.readInt();
-		} catch (IOException e) {
-			throw new RuntimeException("Cannot read input.", e);
-		}
-	}
-
-	@Override
-	protected long _getLong(int paramInt) {
-		try {
-			return input.readLong();
-		} catch (IOException e) {
-			throw new RuntimeException("Cannot read input.", e);
-		}
-	}
-
-	@Override
-	protected void _setByte(int index, int value) {
-		try {
-			output.writeByte(value);
-		} catch (IOException e) {
-			throw new RuntimeException("Cannot write output.", e);
-		}
-	}
-
-	@Override
-	protected void _setShort(int index, int value) {
-		try {
-			output.writeShort(value);
-		} catch (IOException e) {
-			throw new RuntimeException("Cannot write output.", e);
-		}
-	}
-
-	@Override
-	protected void _setMedium(int index, int value) {
-		try {
-			output.writeShort(value);
-		} catch (IOException e) {
-			throw new RuntimeException("Cannot write output.", e);
-		}
-	}
-
-	@Override
-	protected void _setInt(int index, int value) {
-		try {
-			output.writeInt(value);
-		} catch (IOException e) {
-			throw new RuntimeException("Cannot write output.", e);
-		}
-	}
-
-	@Override
-	protected void _setLong(int index, long value) {
-		try {
-			output.writeLong(value);
-		} catch (IOException e) {
-			throw new RuntimeException("Cannot write output.", e);
-		}
-	}
-
-	@Override
-	public int capacity() {
-		return CAPACITY;
-	}
-
-	@Override
-	public ByteBuf capacity(int paramInt) {
-		return this;
-	}
-
-	@Override
-	public ByteBufAllocator alloc() {
-		return null;
-	}
-
-	@Override
-	public ByteOrder order() {
-		return ByteOrder.LITTLE_ENDIAN;
-	}
-
-	@Override
-	public ByteBuf unwrap() {
-		return null;
-	}
-
-	@Override
-	public boolean isDirect() {
-		return false;
-	}
-
-	@Override
-	public ByteBuf getBytes(int index, ByteBuf dst, int dstIndex, int length) {
-		try {
-			for (int i = 0; i < length; i++) {
-				dst.setByte(dstIndex + i, input.read());
-			}
-		} catch (IOException e) {
-			throw new RuntimeException("Cannot read input.", e);
-		}
-		return this;
-	}
-
-	@Override
-	public ByteBuf getBytes(int index, byte[] dst, int dstIndex, int length) {
-		try {
-			input.read(dst, dstIndex, length);
-		} catch (IOException e) {
-			throw new RuntimeException("Cannot read input.", e);
-		}
-		return this;
-	}
-
-	@Override
-	public ByteBuf getBytes(int index, ByteBuffer dst) {
-		try {
-			dst.put(ByteStreams.toByteArray(input));
-		} catch (IOException e) {
-			throw new RuntimeException("Cannot read input.", e);
-		}
-		return this;
-	}
-
-	@Override
-	public ByteBuf getBytes(int index, OutputStream dst, int length) throws IOException {
-		ByteStreams.copy(ByteStreams.limit(input, length), dst);
-		return this;
-	}
-
-	@Override
-	public int getBytes(int index, GatheringByteChannel out, int length) throws IOException {
-		byte[] data = ByteStreams.toByteArray(ByteStreams.limit(input, length));
-		
-		out.write(ByteBuffer.wrap(data));
-		return data.length;
-	}
-
-	@Override
-	public ByteBuf setBytes(int index, ByteBuf src, int srcIndex, int length) {
-		byte[] buffer = new byte[length];
-		src.getBytes(srcIndex, buffer);
-		
-		try {
-			output.write(buffer);
-			return this;
-		} catch (IOException e) {
-			throw new RuntimeException("Cannot write output.", e);
-		}
-	}
-
-	@Override
-	public ByteBuf setBytes(int index, byte[] src, int srcIndex, int length) {
-		try {
-			output.write(src, srcIndex, length);
-			return this;
-		} catch (IOException e) {
-			throw new RuntimeException("Cannot write output.", e);
-		}
-	}
-
-	@Override
-	public ByteBuf setBytes(int index, ByteBuffer src) {
-		try {
-			WritableByteChannel channel = Channels.newChannel(output);
-
-			channel.write(src);
-			return this;
-		} catch (IOException e) {
-			throw new RuntimeException("Cannot write output.", e);
-		}
-	}
-
-	@Override
-	public int setBytes(int index, InputStream in, int length) throws IOException {
-		InputStream limit = ByteStreams.limit(in, length);
-		ByteStreams.copy(limit, output);
-		return length - limit.available();
-	}
-
-	@Override
-	public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
-		ByteBuffer buffer = ByteBuffer.allocate(length);
-		WritableByteChannel channel = Channels.newChannel(output);
-		
-		int count = in.read(buffer);
-		channel.write(buffer);
-		return count;
-	}
-
-	@Override
-	public ByteBuf copy(int index, int length) {
-		throw new UnsupportedOperationException("Cannot seek in input stream.");
-	}
-
-	@Override
-	public int nioBufferCount() {
-		return 0;
-	}
-
-	@Override
-	public ByteBuffer nioBuffer(int paramInt1, int paramInt2) {
-		throw new UnsupportedOperationException();
-	}
-
-	@Override
-	public ByteBuffer internalNioBuffer(int paramInt1, int paramInt2) {
-		return null;
-	}
-
-	@Override
-	public ByteBuffer[] nioBuffers(int paramInt1, int paramInt2) {
-		return null;
-	}
-
-	@Override
-	public boolean hasArray() {
-		return false;
-	}
-
-	@Override
-	public byte[] array() {
-		return null;
-	}
-
-	@Override
-	public int arrayOffset() {
-		return 0;
-	}
-
-	@Override
-	public boolean hasMemoryAddress() {
-		return false;
-	}
-
-	@Override
-	public long memoryAddress() {
-		return 0;
-	}
-
-	@Override
-	public ByteBuf retain(int paramInt) {
-		return this;
-	}
-
-	@Override
-	public ByteBuf retain() {
-		return this;
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/injector/netty/NettyProtocolRegistry.java

@@ -1,111 +0,0 @@
-/**
- *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
- *  Copyright (C) 2015 dmulloy2
- *
- *  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.injector.netty;
-
-import java.util.Map;
-import java.util.Map.Entry;
-
-import com.comphenix.protocol.PacketType;
-import com.comphenix.protocol.ProtocolLogger;
-import com.comphenix.protocol.PacketType.Protocol;
-import com.comphenix.protocol.PacketType.Sender;
-import com.comphenix.protocol.injector.netty.ProtocolRegistry;
-import com.comphenix.protocol.injector.packet.MapContainer;
-import com.comphenix.protocol.reflect.StructureModifier;
-import com.google.common.collect.Maps;
-
-/**
- * @author dmulloy2
- */
-
-public class NettyProtocolRegistry extends ProtocolRegistry {
-
-	public NettyProtocolRegistry() {
-		super();
-	}
-
-	@Override
-	protected synchronized void initialize() {
-		ProtocolLogger.debug("Initializing the Netty protocol registry"); // Debug for issue #202
-
-		Object[] protocols = enumProtocol.getEnumConstants();
-
-		// ID to Packet class maps
-		Map<Object, Map<Integer, Class<?>>> serverMaps = Maps.newLinkedHashMap();
-		Map<Object, Map<Integer, Class<?>>> clientMaps = Maps.newLinkedHashMap();
-
-		Register result = new Register();
-		StructureModifier<Object> modifier = null;
-
-		// Iterate through the protocols
-		for (Object protocol : protocols) {
-			if (modifier == null)
-				modifier = new StructureModifier<Object>(protocol.getClass().getSuperclass(), false);
-			StructureModifier<Map<Object, Map<Integer, Class<?>>>> maps = modifier.withTarget(protocol).withType(Map.class);
-			for (Entry<Object, Map<Integer, Class<?>>> entry : maps.read(0).entrySet()) {
-				String direction = entry.getKey().toString();
-				if (direction.contains("CLIENTBOUND")) { // Sent by Server
-					serverMaps.put(protocol, entry.getValue());
-				} else if (direction.contains("SERVERBOUND")) { // Sent by Client
-					clientMaps.put(protocol, entry.getValue());
-				}
-			}
-		}
-
-		// Maps we have to occasionally check have changed
-		for (Map<Integer, Class<?>> map : serverMaps.values()) {
-			result.containers.add(new MapContainer(map));
-		}
-
-		for (Map<Integer, Class<?>> map : clientMaps.values()) {
-			result.containers.add(new MapContainer(map));
-		}
-
-		for (int i = 0; i < protocols.length; i++) {
-			Object protocol = protocols[i];
-			Enum<?> enumProtocol = (Enum<?>) protocol;
-			Protocol equivalent = Protocol.fromVanilla(enumProtocol);
-			
-			// Associate known types
-			if (serverMaps.containsKey(protocol))
-				associatePackets(result, serverMaps.get(protocol), equivalent, Sender.SERVER);
-			if (clientMaps.containsKey(protocol))
-				associatePackets(result, clientMaps.get(protocol), equivalent, Sender.CLIENT);
-		}
-
-		// Exchange (thread safe, as we have only one writer)
-		this.register = result;
-	}
-
-	@Override
-	protected void associatePackets(Register register, Map<Integer, Class<?>> lookup, Protocol protocol, Sender sender) {
-		for (Entry<Integer, Class<?>> entry : lookup.entrySet()) {
-			PacketType type = PacketType.fromCurrent(protocol, sender, entry.getKey(), entry.getValue());
-
-			try {
-				register.typeToClass.put(type, entry.getValue());
-
-				if (sender == Sender.SERVER)
-					register.serverPackets.add(type);
-				if (sender == Sender.CLIENT)
-					register.clientPackets.add(type);
-			} catch (IllegalArgumentException ex) {
-				// Sometimes this happens with fake packets, just ignore it
-			}
-		}
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/injector/netty/ProtocolRegistry.java

@@ -1,125 +0,0 @@
-package com.comphenix.protocol.injector.netty;
-
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import com.comphenix.protocol.PacketType;
-import com.comphenix.protocol.PacketType.Protocol;
-import com.comphenix.protocol.PacketType.Sender;
-import com.comphenix.protocol.injector.packet.MapContainer;
-import com.comphenix.protocol.utility.MinecraftReflection;
-import com.google.common.collect.BiMap;
-import com.google.common.collect.HashBiMap;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Sets;
-
-/**
- * Represents a way of accessing the new netty Protocol enum.
- * @author Kristian
- */
-
-public abstract class ProtocolRegistry {
-	/**
-	 * Represents a register we are currently building.
-	 * @author Kristian
-	 */
-	protected static class Register {
-		// The main lookup table
-		public BiMap<PacketType, Class<?>> typeToClass = HashBiMap.create();
-		public volatile Set<PacketType> serverPackets = Sets.newHashSet();
-		public volatile Set<PacketType> clientPackets = Sets.newHashSet();
-		public List<MapContainer> containers = Lists.newArrayList();
-
-		public Register() {
-		}
-
-		/**
-		 * Determine if the current register is outdated.
-		 * @return TRUE if it is, FALSE otherwise.
-		 */
-		public boolean isOutdated() {
-			for (MapContainer container : containers) {
-				if (container.hasChanged()) {
-					return true;
-				}
-			}
-			return false;
-		}
-	}
-	
-	protected Class<?> enumProtocol;
-	
-	// Current register
-	protected volatile Register register;
-	
-	public ProtocolRegistry() {
-		enumProtocol = MinecraftReflection.getEnumProtocolClass();
-		initialize();
-	}
-	
-	/**
-	 * Retrieve an immutable view of the packet type lookup.
-	 * @return The packet type lookup.
-	 */
-	public Map<PacketType, Class<?>> getPacketTypeLookup() {
-		return Collections.unmodifiableMap(register.typeToClass);
-	}
-	
-	/**
-	 * Retrieve an immutable view of the class to packet type lookup.
-	 * @return The packet type lookup.
-	 */
-	public Map<Class<?>, PacketType> getPacketClassLookup() {
-		return Collections.unmodifiableMap(register.typeToClass.inverse());
-	}
-	
-	/**
-	 * Retrieve every known client packet, from every protocol.
-	 * @return Every client packet.
-	 */
-	public Set<PacketType> getClientPackets() {
-		return Collections.unmodifiableSet(register.clientPackets);
-	}
-	
-	/**
-	 * Retrieve every known server packet, from every protocol.
-	 * @return Every server packet.
-	 */
-	public Set<PacketType> getServerPackets() {
-		return Collections.unmodifiableSet(register.serverPackets);
-	}
-	
-	/**
-	 * Ensure that our local register is up-to-date with Minecraft.
-	 * <p>
-	 * This operation may block the calling thread.
-	 */
-	public synchronized void synchronize() {
-		// Check if the packet registry has changed
-		if (register.isOutdated()) {
-			initialize();
-		}
-	}
-	
-	/**
-	 * Load the packet lookup tables in each protocol.
-	 */
-	protected abstract void initialize();
-
-	protected abstract void associatePackets(Register register, Map<Integer, Class<?>> lookup, Protocol protocol, Sender sender);
-
-	/**
-	 * Retrieve the number of mapping in all the maps.
-	 * @param maps - iterable of maps.
-	 * @return The sum of all the entries.
-	 */
-	protected final int sum(Iterable<? extends Map<Integer, Class<?>>> maps) {
-		int count = 0;
-
-		for (Map<Integer, Class<?>> map : maps)
-			count += map.size();
-		return count;
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/injector/netty/WirePacket.java

@@ -1,255 +0,0 @@
-/**
- *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
- *  Copyright (C) 2015 dmulloy2
- *
- *  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.injector.netty;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.lang.reflect.Method;
-import java.util.Arrays;
-
-import com.comphenix.protocol.PacketType;
-import com.comphenix.protocol.events.PacketContainer;
-import com.comphenix.protocol.utility.MinecraftMethods;
-import com.comphenix.protocol.utility.MinecraftReflection;
-
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.Unpooled;
-
-/**
- * A packet represented only by its id and bytes.
- * @author dmulloy2
- */
-public class WirePacket {
-	private final int id;
-	private final byte[] bytes;
-
-	/**
-	 * Constructs a new WirePacket with a given type and contents
-	 * @param type Type of the packet
-	 * @param bytes Contents of the packet
-	 */
-	public WirePacket(PacketType type, byte[] bytes) {
-		this.id = checkNotNull(type, "type cannot be null").getCurrentId();
-		this.bytes = bytes;
-	}
-
-	/**
-	 * Constructs a new WirePacket with a given id and contents
-	 * @param id ID of the packet
-	 * @param bytes Contents of the packet
-	 */
-	public WirePacket(int id, byte[] bytes) {
-		this.id = id;
-		this.bytes = bytes;
-	}
-
-	/**
-	 * Gets this packet's ID
-	 * @return The ID
-	 */
-	public int getId() {
-		return id;
-	}
-
-	/**
-	 * Gets this packet's contents as a byte array
-	 * @return The contents
-	 */
-	public byte[] getBytes() {
-		return bytes;
-	}
-
-	/**
-	 * Writes the id of this packet to a given output
-	 * @param output Output to write to
-	 */
-	public void writeId(ByteBuf output) {
-		writeVarInt(output, id);
-	}
-
-	/**
-	 * Writes the contents of this packet to a given output
-	 * @param output Output to write to
-	 */
-	public void writeBytes(ByteBuf output) {
-		checkNotNull(output, "output cannot be null!");
-		output.writeBytes(bytes);
-	}
-
-	/**
-	 * Fully writes the ID and contents of this packet to a given output
-	 * @param output Output to write to
-	 */
-	public void writeFully(ByteBuf output) {
-		writeId(output);
-		writeBytes(output);
-	}
-
-	/**
-	 * Serializes this packet into a byte buffer
-	 * @return The buffer
-	 */
-	public ByteBuf serialize() {
-		ByteBuf buffer = Unpooled.buffer();
-		writeFully(buffer);
-		return buffer;
-	}
-
-	@Override
-	public boolean equals(Object obj) {
-		if (this == obj) return true;
-
-		if (obj instanceof WirePacket) {
-			WirePacket that = (WirePacket) obj;
-			return this.id == that.id &&
-					Arrays.equals(this.bytes, that.bytes);
-		}
-
-		return false;
-	}
-
-	@Override
-	public int hashCode() {
-		final int prime = 31;
-		int result = 1;
-		result = prime * result + Arrays.hashCode(bytes);
-		result = prime * result + id;
-		return result;
-	}
-
-	@Override
-	public String toString() {
-		return "WirePacket[id=" + id + ", bytes=" + Arrays.toString(bytes) + "]";
-	}
-
-	private static byte[] getBytes(ByteBuf buffer) {
-		byte[] array = new byte[buffer.readableBytes()];
-		buffer.readBytes(array);
-		return array;
-	}
-
-	/**
-	 * Creates a WirePacket from an existing PacketContainer
-	 * @param packet Existing packet
-	 * @return The resulting WirePacket
-	 */
-	public static WirePacket fromPacket(PacketContainer packet) {
-		int id = packet.getType().getCurrentId();
-		return new WirePacket(id, bytesFromPacket(packet));
-	}
-
-	/**
-	 * Creates a byte array from an existing PacketContainer containing all the
-	 * bytes from that packet
-	 * 
-	 * @param packet Existing packet
-	 * @return The ByteBuf
-	 */
-	public static byte[] bytesFromPacket(PacketContainer packet) {
-		checkNotNull(packet, "packet cannot be null!");
-		
-		ByteBuf buffer = PacketContainer.createPacketBuffer();
-		ByteBuf store = PacketContainer.createPacketBuffer();
-		
-		// Read the bytes once
-		Method write = MinecraftMethods.getPacketWriteByteBufMethod();
-
-		try {
-			write.invoke(packet.getHandle(), buffer);
-		} catch (ReflectiveOperationException ex) {
-			throw new RuntimeException("Failed to read packet contents.", ex);
-		}
-
-		byte[] bytes = getBytes(buffer);
-
-		// Rewrite them to the packet to avoid issues with certain packets
-		if (packet.getType() == PacketType.Play.Server.CUSTOM_PAYLOAD
-				|| packet.getType() == PacketType.Play.Client.CUSTOM_PAYLOAD) {
-			// Make a copy of the array before writing
-			byte[] ret = Arrays.copyOf(bytes, bytes.length);
-			store.writeBytes(bytes);
-
-			Method read = MinecraftMethods.getPacketReadByteBufMethod();
-
-			try {
-				read.invoke(packet.getHandle(), store);
-			} catch (ReflectiveOperationException ex) {
-				throw new RuntimeException("Failed to rewrite packet contents.", ex);
-			}
-
-			return ret;
-		}
-
-		return bytes;
-	}
-
-	/**
-	 * Creates a WirePacket from an existing Minecraft packet
-	 * @param packet Existing Minecraft packet
-	 * @return The resulting WirePacket
-	 * @throws IllegalArgumentException If the packet is null or not a Minecraft packet
-	 */
-	public static WirePacket fromPacket(Object packet) {
-		checkNotNull(packet, "packet cannot be null!");
-		checkArgument(MinecraftReflection.isPacketClass(packet), "packet must be a Minecraft packet");
-
-		PacketType type = PacketType.fromClass(packet.getClass());
-		int id = type.getCurrentId();
-
-		ByteBuf buffer = PacketContainer.createPacketBuffer();
-		Method write = MinecraftMethods.getPacketWriteByteBufMethod();
-
-		try {
-			write.invoke(packet, buffer);
-		} catch (ReflectiveOperationException ex) {
-			throw new RuntimeException("Failed to serialize packet contents.", ex);
-		}
-
-		return new WirePacket(id, getBytes(buffer));
-	}
-
-	public static void writeVarInt(ByteBuf output, int i) {
-		checkNotNull(output, "output cannot be null!");
-
-		while ((i & -128) != 0) {
-			output.writeByte(i & 127 | 128);
-			i >>>= 7;
-		}
-
-		output.writeByte(i);
-	}
-
-	public static int readVarInt(ByteBuf input) {
-		checkNotNull(input, "input cannot be null!");
-
-        int i = 0;
-        int j = 0;
-
-        byte b0;
-
-        do {
-            b0 = input.readByte();
-            i |= (b0 & 127) << j++ * 7;
-            if (j > 5) {
-                throw new RuntimeException("VarInt too big");
-            }
-        } while ((b0 & 128) == 128);
-
-        return i;
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/injector/packet/MapContainer.java

@@ -1,71 +0,0 @@
-package com.comphenix.protocol.injector.packet;
-
-import java.lang.reflect.Field;
-
-import com.comphenix.protocol.reflect.FieldUtils;
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * Represents a class that can detect if a map has changed.
- * @author Kristian
- */
-public class MapContainer {
-	// For detecting changes
-	private final Field modCountField;
-	private int lastModCount;
-	
-	// The object along with whether or not this is the initial run
-	private final Object source;
-	private boolean changed;
-	
-	public MapContainer(Object source) {
-		this.source = source;
-		this.changed = false;
-		
-		Field modCountField = FieldUtils.getField(source.getClass(), "modCount", true);
-		this.modCountField = checkNotNull(modCountField, "Could not obtain modCount field");
-		this.lastModCount = getModificationCount();
-	}
-	
-	/**
-	 * 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
-	 */
-	private int getModificationCount() {
-		try {
-			return modCountField.getInt(source);
-		} catch (ReflectiveOperationException ex) {
-			throw new RuntimeException("Unable to retrieve modCount.", ex);
-		}
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/injector/packet/PacketRegistry.java

@@ -1,357 +0,0 @@
-/*
- *  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.injector.packet;
-
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-
-import com.comphenix.protocol.PacketType;
-import com.comphenix.protocol.PacketType.Sender;
-import com.comphenix.protocol.error.ReportType;
-import com.comphenix.protocol.injector.netty.NettyProtocolRegistry;
-import com.comphenix.protocol.injector.netty.ProtocolRegistry;
-import com.comphenix.protocol.reflect.FieldAccessException;
-import com.comphenix.protocol.utility.MinecraftReflection;
-import com.google.common.base.Function;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
-
-/**
- * Static packet registry in Minecraft.
- * @author Kristian
- */
-@SuppressWarnings("rawtypes")
-public class PacketRegistry {
-	public static final ReportType REPORT_CANNOT_CORRECT_TROVE_MAP = new ReportType("Unable to correct no entry value.");
-	
-	public static final ReportType REPORT_INSUFFICIENT_SERVER_PACKETS = new ReportType("Too few server packets detected: %s");
-	public static final ReportType REPORT_INSUFFICIENT_CLIENT_PACKETS = new ReportType("Too few client packets detected: %s");
-
-	// The Netty packet registry
-	private static volatile ProtocolRegistry NETTY;
-
-	// Cached for Netty
-	private static volatile Set<Integer> LEGACY_SERVER_PACKETS;
-	private static volatile Set<Integer> LEGACY_CLIENT_PACKETS;
-	private static volatile Map<Integer, Class> LEGACY_PREVIOUS_PACKETS;
-
-	// Whether or not the registry has been initialized
-	private static volatile boolean INITIALIZED = false;
-
-	/**
-	 * Initializes the packet registry.
-	 */
-	private static void initialize() {
-		if (INITIALIZED) {
-			if (NETTY == null) {
-				throw new IllegalStateException("Failed to initialize packet registry.");
-			}
-			return;
-		}
-
-		NETTY = new NettyProtocolRegistry();
-		INITIALIZED = true;
-	}
-
-	/**
-	 * Determine if the given packet type is supported on the current server.
-	 * @param type - the type to check.
-	 * @return TRUE if it is, FALSE otherwise.
-	 */
-	public static boolean isSupported(PacketType type) {
-		initialize();
-		return NETTY.getPacketTypeLookup().containsKey(type);
-	}
-
-	/**
-	 * Retrieve a map of every packet class to every ID.
-	 * <p>
-	 * Deprecated: Use {@link #getPacketToType()} instead.
-	 * @return A map of packet classes and their corresponding ID.
-	 */
-	@Deprecated
-	public static Map<Class, Integer> getPacketToID() {
-		initialize();
-
-		@SuppressWarnings("unchecked")
-		Map<Class, Integer> result = (Map) Maps.transformValues(
-				NETTY.getPacketClassLookup(),
-				new Function<PacketType, Integer>() {
-					@Override
-					public Integer apply(PacketType type) {
-						return type.getLegacyId();
-					};
-				});
-		return result;
-	}
-
-	/**
-	 * Retrieve a map of every packet class to the respective packet type.
-	 * @return A map of packet classes and their corresponding packet type.
-	 */
-	public static Map<Class, PacketType> getPacketToType() {
-		initialize();
-
-		@SuppressWarnings("unchecked")
-		Map<Class, PacketType> result = (Map) NETTY.getPacketClassLookup();
-		return result;
-	}
-	
-	/**
-	 * Retrieve the injected proxy classes handlig each packet ID.
-	 * <p>
-	 * This is not supported in 1.7.2 and later.
-	 * @return Injected classes.
-	 */
-	@Deprecated
-	public static Map<Integer, Class> getOverwrittenPackets() {
-		initialize();
-		throw new IllegalStateException("Not supported on Netty.");
-	}
-
-	/**
-	 * Retrieve the vanilla classes handling each packet ID.
-	 * @return Vanilla classes.
-	 */
-	@Deprecated
-	public static Map<Integer, Class> getPreviousPackets() {
-		initialize();
-
-		// Construct it first
-		if (LEGACY_PREVIOUS_PACKETS == null) {
-			Map<Integer, Class> map = Maps.newHashMap();
-
-			for (Entry<PacketType, Class<?>> entry : NETTY.getPacketTypeLookup().entrySet()) {
-				map.put(entry.getKey().getLegacyId(), entry.getValue());
-			}
-			LEGACY_PREVIOUS_PACKETS = Collections.unmodifiableMap(map);
-		}
-		return LEGACY_PREVIOUS_PACKETS;
-	}
-
-	/**
-	 * Retrieve every known and supported server packet.
-	 * <p>
-	 * Deprecated: Use {@link #getServerPacketTypes()} instead.
-	 * @return An immutable set of every known server packet.
-	 * @throws FieldAccessException If we're unable to retrieve the server packet data from Minecraft.
-	 */
-	@Deprecated
-	public static Set<Integer> getServerPackets() throws FieldAccessException {
-		if (LEGACY_SERVER_PACKETS == null) {
-			LEGACY_SERVER_PACKETS = toLegacy(getServerPacketTypes());
-		}
-
-		return LEGACY_SERVER_PACKETS;
-	}
-	
-	/**
-	 * Retrieve every known and supported server packet type.
-	 * @return Every server packet type.
-	 */
-	public static Set<PacketType> getServerPacketTypes() {
-		initialize();
-		NETTY.synchronize();
-
-		Set<PacketType> types = new HashSet<>();
-
-		// Filter out unsupported packets
-		for (PacketType type : NETTY.getServerPackets()) {
-			if (!type.isDeprecated()) {
-				types.add(type);
-			}
-		}
-
-		return types;
-	}
-	
-	/**
-	 * Retrieve every known and supported client packet.
-	 * <p>
-	 * Deprecated: Use {@link #getClientPacketTypes()} instead.
-	 * @return An immutable set of every known client packet.
-	 * @throws FieldAccessException If we're unable to retrieve the client packet data from Minecraft.
-	 */
-	@Deprecated
-	public static Set<Integer> getClientPackets() throws FieldAccessException {
-		if (LEGACY_CLIENT_PACKETS == null) {
-			LEGACY_CLIENT_PACKETS = toLegacy(getClientPacketTypes());
-		}
-
-		return LEGACY_CLIENT_PACKETS;
-	}
-	
-	/**
-	 * Retrieve every known and supported server packet type.
-	 * @return Every server packet type.
-	 */
-	public static Set<PacketType> getClientPacketTypes() {
-		initialize();
-		NETTY.synchronize();
-
-		Set<PacketType> types = new HashSet<>();
-
-		// Filter out unsupported packets
-		for (PacketType type : NETTY.getClientPackets()) {
-			if (!type.isDeprecated()) {
-				types.add(type);
-			}
-		}
-
-		return types;
-	}
-	
-	/**
-	 * Convert a set of packet types to a set of integers based on the legacy packet ID.
-	 * @param types - packet type.
-	 * @return Set of integers.
-	 */
-	public static Set<Integer> toLegacy(Set<PacketType> types) {
-		Set<Integer> result = Sets.newHashSet();
-		
-		for (PacketType type : types)
-			result.add(type.getLegacyId());
-		return Collections.unmodifiableSet(result);
-	}
-	
-	/**
-	 * Convert a set of legacy packet IDs to packet types.
-	 * @param ids - legacy packet IDs.
-	 * @return Set of packet types.
-	 */
-	public static Set<PacketType> toPacketTypes(Set<Integer> ids) {
-		return toPacketTypes(ids, null);
-	}
-	
-	/**
-	 * Convert a set of legacy packet IDs to packet types.
-	 * @param ids - legacy packet IDs.
-	 * @param preference - the sender preference, if any.
-	 * @return Set of packet types.
-	 */
-	public static Set<PacketType> toPacketTypes(Set<Integer> ids, Sender preference) {
-		Set<PacketType> result = Sets.newHashSet();
-		
-		for (int id : ids)
-			result.add(PacketType.fromLegacy(id, preference));
-		return Collections.unmodifiableSet(result);
-	}
-	
-	/**
-	 * Retrieves the correct packet class from a given packet ID.
-	 * <p>
-	 * Deprecated: Use {@link #getPacketClassFromType(PacketType)} instead.
-	 * @param packetID - the packet ID.
-	 * @return The associated class.
-	 */
-	@Deprecated
-	public static Class getPacketClassFromID(int packetID) {
-		initialize();
-		return NETTY.getPacketTypeLookup().get(PacketType.findLegacy(packetID));
-	}
-	
-	/**
-	 * Retrieves the correct packet class from a given type.
-	 * @param type - the packet type.
-	 * @return The associated class.
-	 */
-	public static Class getPacketClassFromType(PacketType type) {
-		return getPacketClassFromType(type, false);
-	}
-	
-	/**
-	 * Retrieves the correct packet class from a given type.
-	 * <p>
-	 * Note that forceVanillla will be ignored on MC 1.7.2 and later.
-	 * @param type - the packet type.
-	 * @param forceVanilla - whether or not to look for vanilla classes, not injected classes.
-	 * @return The associated class.
-	 */
-	public static Class getPacketClassFromType(PacketType type, boolean forceVanilla) {
-		initialize();
-
-		// Try the lookup first
-		Class<?> clazz = NETTY.getPacketTypeLookup().get(type);
-		if (clazz != null) {
-			return clazz;
-		}
-
-		// Then try looking up the class names
-		for (String name : type.getClassNames()) {
-			try {
-				clazz = MinecraftReflection.getMinecraftClass(name);
-				break;
-			} catch (Exception ex) {
-			}
-		}
-
-		// TODO Cache the result?
-		return clazz;
-	}
-
-	/**
-	 * Retrieves the correct packet class from a given packet ID.
-	 * <p>
-	 * This method has been deprecated.
-	 * @param packetID - the packet ID.
- 	 * @param forceVanilla - whether or not to look for vanilla classes, not injected classes.
-	 * @return The associated class.
-	 */
-	@Deprecated
-	public static Class getPacketClassFromID(int packetID, boolean forceVanilla) {
-		initialize();
-		return getPacketClassFromID(packetID);
-	}
-
-	/**
-	 * Retrieve the packet ID of a given packet.
-	 * <p>
-	 * Deprecated: Use {@link #getPacketType(Class)}.
-	 * @param packet - the type of packet to check.
-	 * @return The legacy ID of the given packet.
-	 * @throws IllegalArgumentException If this is not a valid packet.
-	 */
-	@Deprecated
-	public static int getPacketID(Class<?> packet) {
-		initialize();
-		return NETTY.getPacketClassLookup().get(packet).getLegacyId();
-	}
-
-	/**
-	 * Retrieve the packet type of a given packet.
-	 * @param packet - the class of the packet.
-	 * @return The packet type, or NULL if not found.
-	 */
-	public static PacketType getPacketType(Class<?> packet) {
-		return getPacketType(packet, null);
-	}
-	
-	/**
-	 * Retrieve the packet type of a given packet.
-	 * @param packet - the class of the packet.
-	 * @param sender - the sender of the packet, or NULL.
-	 * @return The packet type, or NULL if not found.
-	 */
-	public static PacketType getPacketType(Class<?> packet, Sender sender) {
-		initialize();
-		return NETTY.getPacketClassLookup().get(packet);
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/reflect/ClassAnalyser.java

@@ -1,138 +0,0 @@
-package com.comphenix.protocol.reflect;
-
-import java.io.IOException;
-import java.lang.reflect.Method;
-import java.util.List;
-
-import net.sf.cglib.asm.ClassReader;
-import net.sf.cglib.asm.MethodVisitor;
-import net.sf.cglib.asm.Opcodes;
-import net.sf.cglib.asm.Type;
-
-import com.comphenix.protocol.reflect.ClassAnalyser.AsmMethod.AsmOpcodes;
-import com.comphenix.protocol.reflect.compiler.EmptyClassVisitor;
-import com.comphenix.protocol.reflect.compiler.EmptyMethodVisitor;
-import com.google.common.collect.Lists;
-
-public class ClassAnalyser {
-	/**
-	 * Represents a method in ASM.
-	 * <p>
-	 * Keep in mind that this may also invoke a constructor.
-	 * @author Kristian
-	 */
-	public static class AsmMethod {
-		public enum AsmOpcodes {
-			INVOKE_VIRTUAL,
-			INVOKE_SPECIAL,
-			INVOKE_STATIC,
-			INVOKE_INTERFACE,
-			INVOKE_DYNAMIC;
-			
-			public static AsmOpcodes fromIntOpcode(int opcode) {
-				switch (opcode) {
-					case Opcodes.INVOKEVIRTUAL: return AsmOpcodes.INVOKE_VIRTUAL;
-					case Opcodes.INVOKESPECIAL: return AsmOpcodes.INVOKE_SPECIAL;
-					case Opcodes.INVOKESTATIC: return AsmOpcodes.INVOKE_STATIC;
-					case Opcodes.INVOKEINTERFACE: return AsmOpcodes.INVOKE_INTERFACE;
-					case Opcodes.INVOKEDYNAMIC: return AsmOpcodes.INVOKE_DYNAMIC;
-					default: throw new IllegalArgumentException("Unknown opcode: " + opcode);
-				}
-			}
-		}
-		
-		private final AsmOpcodes opcode;
-		private final String ownerClass;
-		private final String methodName;
-		private final String signature;
-		
-		public AsmMethod(AsmOpcodes opcode, String ownerClass, String methodName, String signature) {
-			this.opcode = opcode;
-			this.ownerClass = ownerClass;
-			this.methodName = methodName;
-			this.signature = signature;
-		}
-
-		public String getOwnerName() {
-			return ownerClass;
-		}
-		
-		/**
-		 * Retrieve the opcode used to invoke this method or constructor.
-		 * @return The opcode.
-		 */
-		public AsmOpcodes getOpcode() {
-			return opcode;
-		}
-		
-		/**
-		 * Retrieve the associated owner class.
-		 * @return The owner class.
-		 * @throws ClassNotFoundException If the class was not found
-		 */
-		public Class<?> getOwnerClass() throws ClassNotFoundException {
-			return AsmMethod.class.getClassLoader().loadClass(getOwnerName().replace('/', '.'));
-		}
-		
-		public String getMethodName() {
-			return methodName;
-		}
-		
-		public String getSignature() {
-			return signature;
-		}
-	}
-	private static final ClassAnalyser DEFAULT = new ClassAnalyser();
-	
-	/**
-	 * Retrieve the default instance.
-	 * @return The default.
-	 */
-	public static ClassAnalyser getDefault() {
-		return DEFAULT;
-	}
-
-	/**
-	 * Retrieve every method calls in the given method.
-	 * @param method - the method to analyse.
-	 * @return The method calls.
-	 * @throws IOException Cannot access the parent class.
-	 */
-	public List<AsmMethod> getMethodCalls(Method method) throws IOException {
-		return getMethodCalls(method.getDeclaringClass(), method);
-	}
-	
-	/**
-	 * Retrieve every method calls in the given method.
-	 * @param clazz - the parent class.
-	 * @param method - the method to analyse.
-	 * @return The method calls.
-	 * @throws IOException Cannot access the parent class.
-	 */
-	public List<AsmMethod> getMethodCalls(Class<?> clazz, Method method) throws IOException {
-		final ClassReader reader = new ClassReader(clazz.getCanonicalName());
-		final List<AsmMethod> output = Lists.newArrayList();
-		
-		// The method we are looking for
-		final String methodName = method.getName();
-		final String methodDescription = Type.getMethodDescriptor(method);
-		
-		reader.accept(new EmptyClassVisitor() {
-			@Override
-			public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
-				// Check method
-				if (methodName.equals(name) && methodDescription.equals(desc)) {
-					return new EmptyMethodVisitor() {
-						@Override
-						public void visitMethodInsn(int opcode, String owner, String name, String desc) {
-							output.add(new AsmMethod(AsmOpcodes.fromIntOpcode(opcode), owner, methodName, desc));
-						}
-					};
-				}
-				return null;
-			}
-			
-		}, ClassReader.EXPAND_FRAMES);
-		return output;
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/reflect/EquivalentConverter.java

@@ -1,52 +0,0 @@
-/*
- *  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.reflect;
-
-/**
- * Interface that converts generic objects into types and back.
- * 
- * @author Kristian
- * @param <TType> The specific type.
- */
-public interface EquivalentConverter<TType> {
-	/**
-	 * Retrieve a copy of the specific type using an instance of the generic type.
-	 * <p>
-	 * This is usually a wrapper type in the Bukkit API.
-	 * @param generic - the generic type.
-	 * @return The new specific type.
-	 */
-	public TType getSpecific(Object generic);
-	
-	/**
-	 * Retrieve a copy of the generic type from a specific type.
-	 * <p>
-	 * This is usually a native net.minecraft.server type in Minecraft.
-	 * @param genericType - class or super class of the generic type.
-	 * @param specific - the specific type we need to copy.
-	 * @return A copy of the specific type.
-	 */
-	public Object getGeneric(Class<?> genericType, TType specific);
-	
-	/**
-	 * Due to type erasion, we need to explicitly keep a reference to the specific type.
-	 * @return The specific type.
-	 */
-	public Class<TType> getSpecificType();
-}
-

modules/API/src/main/java/com/comphenix/protocol/reflect/ExactReflection.java

@@ -1,143 +0,0 @@
-package com.comphenix.protocol.reflect;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.util.Arrays;
-
-import javax.annotation.Nonnull;
-
-import com.google.common.base.Preconditions;
-
-public class ExactReflection {
-	// The class we're actually representing
-	private Class<?> source;
-	private boolean forceAccess;
-
-	private ExactReflection(Class<?> source, boolean forceAccess) {
-		this.source = Preconditions.checkNotNull(source, "source class cannot be NULL");
-		this.forceAccess = forceAccess;
-	}
-	
-	/**
-	 * Retrieves an exact reflection instance from a given class.
-	 * @param source - the class we'll use.
-	 * @return A fuzzy reflection instance.
-	 */
-	public static ExactReflection fromClass(Class<?> source) {
-		return fromClass(source, false);
-	}
-	
-	/**
-	 * Retrieves an exact reflection instance from a given class.
-	 * @param source - the class we'll use.
-	 * @param forceAccess - whether or not to override scope restrictions.
-	 * @return A fuzzy reflection instance.
-	 */
-	public static ExactReflection fromClass(Class<?> source, boolean forceAccess) {
-		return new ExactReflection(source, forceAccess);
-	}
-	
-	/**
-	 * Retrieves an exact reflection instance from an object.
-	 * @param reference - the object we'll use.
-	 * @return A fuzzy reflection instance that uses the class of the given object.
-	 */
-	public static ExactReflection fromObject(Object reference) {
-		return new ExactReflection(reference.getClass(), false);
-	}
-	
-	/**
-	 * Retrieves an exact reflection instance from an object.
-	 * @param reference - the object we'll use.
-	 * @param forceAccess - whether or not to override scope restrictions.
-	 * @return A fuzzy reflection instance that uses the class of the given object.
-	 */
-	public static ExactReflection fromObject(Object reference, boolean forceAccess) {
-		return new ExactReflection(reference.getClass(), forceAccess);
-	}
-	
-	/**
-	 * Retrieve the first method in the class hierachy with the given name and parameters.
-	 * <p>
-	 * If {@link #isForceAccess()} is TRUE, we will also search for protected and private methods.
-	 * @param methodName - the method name to find, or NULL to look for everything.
-	 * @param parameters - the parameters.
-	 * @return The first matched method.
-	 * @throws IllegalArgumentException If we cannot find a method by this name.
-	 */
-	public Method getMethod(String methodName, Class<?>... parameters) {
-		return getMethod(source,  methodName, parameters);
-	}
-	
-	// For recursion
-	private Method getMethod(Class<?> instanceClass, String methodName, Class<?>... parameters) {
-        for (Method method : instanceClass.getDeclaredMethods()) {
-            if ((forceAccess  		|| Modifier.isPublic(method.getModifiers())) &&
-            	(methodName == null || method.getName().equals(methodName)) && 
-                 Arrays.equals(method.getParameterTypes(), parameters)) {
-                
-                method.setAccessible(true);
-                return method;
-            }
-        }
-        // Search in every superclass
-        if (instanceClass.getSuperclass() != null)
-            return getMethod(instanceClass.getSuperclass(), methodName, parameters);
-        throw new IllegalArgumentException(String.format(
-            "Unable to find method %s (%s) in %s.", methodName, Arrays.asList(parameters), source));
-	}
-	
-	/**
-	 * Retrieve a field in the class hierachy by the given name.
-	 * <p>
-	 * If {@link #isForceAccess()} is TRUE, we will also search for protected and private fields.
-	 * @param fieldName - the field name. Cannot be NULL.
-	 * @return The first matched field.
-	 */
-	public Field getField(String fieldName) {
-		return getField(source, fieldName);
-	}
-	
-	// For recursion
-	private Field getField(Class<?> instanceClass, @Nonnull String fieldName) {
-        // Ignore access rules
-        for (Field field : instanceClass.getDeclaredFields()) {
-            if (field.getName().equals(fieldName)) {
-                field.setAccessible(true);
-                return field;
-            }
-        }
-        
-        // Recursively fild the correct field
-        if (instanceClass.getSuperclass() != null)
-            return getField(instanceClass.getSuperclass(), fieldName);
-        throw new IllegalArgumentException(String.format(
-                "Unable to find field %s in %s.", fieldName, source));
-	}
-	
-	/**
-	 * Retrieve an {@link ExactReflection} object where scope restrictions are ignored.
-	 * @return A copy of the current object.
-	 */
-	public ExactReflection forceAccess() {
-		return new ExactReflection(source, true);
-	}
-	
-	/**
-	 * Determine if we are overriding scope restrictions and will also find 
-	 * private, protected or package members.
-	 * @return TRUE if we are, FALSE otherwise.
-	 */
-	public boolean isForceAccess() {
-		return forceAccess;
-	}
-	
-	/** 
-	 * Retrieve the source class we are searching.
-	 * @return The source.
-	 */
-	public Class<?> getSource() {
-		return source;
-	}
- }

modules/API/src/main/java/com/comphenix/protocol/reflect/FieldUtils.java

@@ -1,527 +0,0 @@
-package com.comphenix.protocol.reflect;
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import java.lang.reflect.AccessibleObject;
-import java.lang.reflect.Field;
-import java.lang.reflect.Member;
-import java.lang.reflect.Modifier;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-
-/**
- * Utilities for working with fields by reflection. Adapted and refactored from
- * the dormant [reflect] Commons sandbox component.
- * <p>
- * The ability is provided to break the scoping restrictions coded by the
- * programmer. This can allow fields to be changed that shouldn't be. This
- * facility should be used with care.
- * 
- * @author Apache Software Foundation
- * @author Matt Benson
- * @since 2.5
- * @version $Id: FieldUtils.java 1057009 2011-01-09 19:48:06Z niallp $
- */
-@SuppressWarnings("rawtypes")
-public class FieldUtils {
-
-	/**
-	 * FieldUtils instances should NOT be constructed in standard programming.
-	 * <p>
-	 * This constructor is public to permit tools that require a JavaBean
-	 * instance to operate.
-	 */
-	public FieldUtils() {
-		super();
-	}
-
-	/**
-	 * Gets an accessible <code>Field</code> by name respecting scope.
-	 * Superclasses/interfaces will be considered.
-	 * 
-	 * @param cls the class to reflect, must not be null
-	 * @param fieldName the field name to obtain
-	 * @return the Field object
-	 * @throws IllegalArgumentException if the class or field name is null
-	 */
-	public static Field getField(Class cls, String fieldName) {
-		Field field = getField(cls, fieldName, false);
-		MemberUtils.setAccessibleWorkaround(field);
-		return field;
-	}
-
-	/**
-	 * Gets an accessible <code>Field</code> by name breaking scope if
-	 * requested. Superclasses/interfaces will be considered.
-	 * 
-	 * @param cls the class to reflect, must not be null
-	 * @param fieldName the field name to obtain
-	 * @param forceAccess whether to break scope restrictions using the
-	 *            <code>setAccessible</code> method. <code>False</code> will
-	 *            only match public fields.
-	 * @return the Field object
-	 * @throws IllegalArgumentException if the class or field name is null
-	 */
-	public static Field getField(final Class cls, String fieldName, boolean forceAccess) {
-		if (cls == null) {
-			throw new IllegalArgumentException("The class must not be null");
-		}
-		if (fieldName == null) {
-			throw new IllegalArgumentException("The field name must not be null");
-		}
-		// Sun Java 1.3 has a bugged implementation of getField hence we write
-		// the
-		// code ourselves
-
-		// getField() will return the Field object with the declaring class
-		// set correctly to the class that declares the field. Thus requesting
-		// the
-		// field on a subclass will return the field from the superclass.
-		//
-		// priority order for lookup:
-		// searchclass private/protected/package/public
-		// superclass protected/package/public
-		// private/different package blocks access to further superclasses
-		// implementedinterface public
-
-		// check up the superclass hierarchy
-		for (Class acls = cls; acls != null; acls = acls.getSuperclass()) {
-			try {
-				Field field = acls.getDeclaredField(fieldName);
-				// getDeclaredField checks for non-public scopes as well
-				// and it returns accurate results
-				if (!Modifier.isPublic(field.getModifiers())) {
-					if (forceAccess) {
-						field.setAccessible(true);
-					} else {
-						continue;
-					}
-				}
-				return field;
-			} catch (NoSuchFieldException ex) {
-				// ignore
-			}
-		}
-		// check the public interface case. This must be manually searched for
-		// in case there is a public supersuperclass field hidden by a
-		// private/package
-		// superclass field.
-		Field match = null;
-		for (Iterator intf = getAllInterfaces(cls).iterator(); intf.hasNext();) {
-			try {
-				Field test = ((Class) intf.next()).getField(fieldName);
-				if (match != null) {
-					throw new IllegalArgumentException("Reference to field " + fieldName
-							+ " is ambiguous relative to " + cls
-							+ "; a matching field exists on two or more implemented interfaces.");
-				}
-				match = test;
-			} catch (NoSuchFieldException ex) {
-				// ignore
-			}
-		}
-		return match;
-	}
-	
-    /**
-     * <p>Gets a <code>List</code> of all interfaces implemented by the given
-     * class and its superclasses.</p>
-     *
-     * <p>The order is determined by looking through each interface in turn as
-     * declared in the source file and following its hierarchy up. Then each
-     * superclass is considered in the same way. Later duplicates are ignored,
-     * so the order is maintained.</p>
-     *
-     * @param cls  the class to look up, may be <code>null</code>
-     * @return the <code>List</code> of interfaces in order,
-     *  <code>null</code> if null input
-     */
-    private static List getAllInterfaces(Class cls) {
-        if (cls == null) {
-            return null;
-        }
-        List<Class> list = new ArrayList<Class>();
-        
-        while (cls != null) {
-            Class[] interfaces = cls.getInterfaces();
-            for (int i = 0; i < interfaces.length; i++) {
-                if (list.contains(interfaces[i]) == false) {
-                    list.add(interfaces[i]);
-                }
-                List superInterfaces = getAllInterfaces(interfaces[i]);
-                for (Iterator it = superInterfaces.iterator(); it.hasNext();) {
-                    Class intface = (Class) it.next();
-                    if (list.contains(intface) == false) {
-                        list.add(intface);
-                    }
-                }
-            }
-            cls = cls.getSuperclass();
-        }
-        return list;
-    }
-
-	/**
-	 * Read an accessible static Field.
-	 * 
-	 * @param field to read
-	 * @return the field value
-	 * @throws IllegalArgumentException if the field is null or not static
-	 * @throws IllegalAccessException if the field is not accessible
-	 */
-	public static Object readStaticField(Field field) throws IllegalAccessException {
-		return readStaticField(field, false);
-	}
-
-	/**
-	 * Read a static Field.
-	 * 
-	 * @param field to read
-	 * @param forceAccess whether to break scope restrictions using the
-	 *            <code>setAccessible</code> method.
-	 * @return the field value
-	 * @throws IllegalArgumentException if the field is null or not static
-	 * @throws IllegalAccessException if the field is not made accessible
-	 */
-	public static Object readStaticField(Field field, boolean forceAccess)
-			throws IllegalAccessException {
-		if (field == null) {
-			throw new IllegalArgumentException("The field must not be null");
-		}
-		if (!Modifier.isStatic(field.getModifiers())) {
-			throw new IllegalArgumentException("The field '" + field.getName() + "' is not static");
-		}
-		return readField(field, (Object) null, forceAccess);
-	}
-
-	/**
-	 * Read the named public static field. Superclasses will be considered.
-	 * 
-	 * @param cls the class to reflect, must not be null
-	 * @param fieldName the field name to obtain
-	 * @return the value of the field
-	 * @throws IllegalArgumentException if the class or field name is null
-	 * @throws IllegalAccessException if the field is not accessible
-	 */
-	public static Object readStaticField(Class cls, String fieldName) throws IllegalAccessException {
-		return readStaticField(cls, fieldName, false);
-	}
-
-	/**
-	 * Read the named static field. Superclasses will be considered.
-	 * 
-	 * @param cls the class to reflect, must not be null
-	 * @param fieldName the field name to obtain
-	 * @param forceAccess whether to break scope restrictions using the
-	 *            <code>setAccessible</code> method. <code>False</code> will
-	 *            only match public fields.
-	 * @return the Field object
-	 * @throws IllegalArgumentException if the class or field name is null
-	 * @throws IllegalAccessException if the field is not made accessible
-	 */
-	public static Object readStaticField(Class cls, String fieldName, boolean forceAccess)
-			throws IllegalAccessException {
-		Field field = getField(cls, fieldName, forceAccess);
-		if (field == null) {
-			throw new IllegalArgumentException("Cannot locate field " + fieldName + " on " + cls);
-		}
-		// already forced access above, don't repeat it here:
-		return readStaticField(field, false);
-	}
-
-	/**
-	 * Read an accessible Field.
-	 * 
-	 * @param field the field to use
-	 * @param target the object to call on, may be null for static fields
-	 * @return the field value
-	 * @throws IllegalArgumentException if the field is null
-	 * @throws IllegalAccessException if the field is not accessible
-	 */
-	public static Object readField(Field field, Object target) throws IllegalAccessException {
-		return readField(field, target, false);
-	}
-
-	/**
-	 * Read a Field.
-	 * 
-	 * @param field the field to use
-	 * @param target the object to call on, may be null for static fields
-	 * @param forceAccess whether to break scope restrictions using the
-	 *            <code>setAccessible</code> method.
-	 * @return the field value
-	 * @throws IllegalArgumentException if the field is null
-	 * @throws IllegalAccessException if the field is not made accessible
-	 */
-	public static Object readField(Field field, Object target, boolean forceAccess) throws IllegalAccessException {
-		if (field == null)
-			throw new IllegalArgumentException("The field must not be null");
-		
-		if (forceAccess && !field.isAccessible()) {
-			field.setAccessible(true);
-		} else {
-			MemberUtils.setAccessibleWorkaround(field);
-		}
-		return field.get(target);
-	}
-
-	/**
-	 * Read the named public field. Superclasses will be considered.
-	 * 
-	 * @param target the object to reflect, must not be null
-	 * @param fieldName the field name to obtain
-	 * @return the value of the field
-	 * @throws IllegalArgumentException if the class or field name is null
-	 * @throws IllegalAccessException if the named field is not public
-	 */
-	public static Object readField(Object target, String fieldName) throws IllegalAccessException {
-		return readField(target, fieldName, false);
-	}
-
-	/**
-	 * Read the named field. Superclasses will be considered.
-	 * 
-	 * @param target the object to reflect, must not be null
-	 * @param fieldName the field name to obtain
-	 * @param forceAccess whether to break scope restrictions using the
-	 *            <code>setAccessible</code> method. <code>False</code> will
-	 *            only match public fields.
-	 * @return the field value
-	 * @throws IllegalArgumentException if the class or field name is null
-	 * @throws IllegalAccessException if the named field is not made accessible
-	 */
-	public static Object readField(Object target, String fieldName, boolean forceAccess)
-			throws IllegalAccessException {
-		if (target == null) {
-			throw new IllegalArgumentException("target object must not be null");
-		}
-		Class cls = target.getClass();
-		Field field = getField(cls, fieldName, forceAccess);
-		if (field == null) {
-			throw new IllegalArgumentException("Cannot locate field " + fieldName + " on " + cls);
-		}
-		// already forced access above, don't repeat it here:
-		return readField(field, target);
-	}
-
-	/**
-	 * Write a public static Field.
-	 * 
-	 * @param field to write
-	 * @param value to set
-	 * @throws IllegalArgumentException if the field is null or not static
-	 * @throws IllegalAccessException if the field is not public or is final
-	 */
-	public static void writeStaticField(Field field, Object value) throws IllegalAccessException {
-		writeStaticField(field, value, false);
-	}
-
-	/**
-	 * Write a static Field.
-	 * 
-	 * @param field to write
-	 * @param value to set
-	 * @param forceAccess whether to break scope restrictions using the
-	 *            <code>setAccessible</code> method. <code>False</code> will
-	 *            only match public fields.
-	 * @throws IllegalArgumentException if the field is null or not static
-	 * @throws IllegalAccessException if the field is not made accessible or is
-	 *             final
-	 */
-	public static void writeStaticField(Field field, Object value, boolean forceAccess)
-			throws IllegalAccessException {
-		if (field == null) {
-			throw new IllegalArgumentException("The field must not be null");
-		}
-		if (!Modifier.isStatic(field.getModifiers())) {
-			throw new IllegalArgumentException("The field '" + field.getName() + "' is not static");
-		}
-		writeField(field, (Object) null, value, forceAccess);
-	}
-
-	/**
-	 * Write a named public static Field. Superclasses will be considered.
-	 * 
-	 * @param cls Class on which the Field is to be found
-	 * @param fieldName to write
-	 * @param value to set
-	 * @throws IllegalArgumentException if the field cannot be located or is not
-	 *             static
-	 * @throws IllegalAccessException if the field is not public or is final
-	 */
-	public static void writeStaticField(Class cls, String fieldName, Object value)
-			throws IllegalAccessException {
-		writeStaticField(cls, fieldName, value, false);
-	}
-
-	/**
-	 * Write a named static Field. Superclasses will be considered.
-	 * 
-	 * @param cls Class on which the Field is to be found
-	 * @param fieldName to write
-	 * @param value to set
-	 * @param forceAccess whether to break scope restrictions using the
-	 *            <code>setAccessible</code> method. <code>False</code> will
-	 *            only match public fields.
-	 * @throws IllegalArgumentException if the field cannot be located or is not
-	 *             static
-	 * @throws IllegalAccessException if the field is not made accessible or is
-	 *             final
-	 */
-	public static void writeStaticField(Class cls, String fieldName, Object value,
-			boolean forceAccess) throws IllegalAccessException {
-		Field field = getField(cls, fieldName, forceAccess);
-		if (field == null) {
-			throw new IllegalArgumentException("Cannot locate field " + fieldName + " on " + cls);
-		}
-		// already forced access above, don't repeat it here:
-		writeStaticField(field, value);
-	}
-
-	public static void writeStaticFinalField(Class<?> clazz, String fieldName, Object value, boolean forceAccess) throws Exception {
-		Field field = getField(clazz, fieldName, forceAccess);
-		if (field == null) {
-			throw new IllegalArgumentException("Cannot locate field " + fieldName + " in " + clazz);
-		}
-
-		field.setAccessible(true);
-
-		Field modifiersField = Field.class.getDeclaredField("modifiers");
-		modifiersField.setAccessible(true);
-		modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
-
-		field.setAccessible(true);
-		field.set(null, value);
-	}
-
-	/**
-	 * Write an accessible field.
-	 * 
-	 * @param field to write
-	 * @param target the object to call on, may be null for static fields
-	 * @param value to set
-	 * @throws IllegalArgumentException if the field is null
-	 * @throws IllegalAccessException if the field is not accessible or is final
-	 */
-	public static void writeField(Field field, Object target, Object value)
-			throws IllegalAccessException {
-		writeField(field, target, value, false);
-	}
-
-	/**
-	 * Write a field.
-	 * 
-	 * @param field to write
-	 * @param target the object to call on, may be null for static fields
-	 * @param value to set
-	 * @param forceAccess whether to break scope restrictions using the
-	 *            <code>setAccessible</code> method. <code>False</code> will
-	 *            only match public fields.
-	 * @throws IllegalArgumentException if the field is null
-	 * @throws IllegalAccessException if the field is not made accessible or is
-	 *             final
-	 */
-	public static void writeField(Field field, Object target, Object value, boolean forceAccess)
-			throws IllegalAccessException {
-		if (field == null) {
-			throw new IllegalArgumentException("The field must not be null");
-		}
-		if (forceAccess && !field.isAccessible()) {
-			field.setAccessible(true);
-		} else {
-			MemberUtils.setAccessibleWorkaround(field);
-		}
-		field.set(target, value);
-	}
-
-	/**
-	 * Write a public field. Superclasses will be considered.
-	 * 
-	 * @param target the object to reflect, must not be null
-	 * @param fieldName the field name to obtain
-	 * @param value to set
-	 * @throws IllegalArgumentException if <code>target</code> or
-	 *             <code>fieldName</code> is null
-	 * @throws IllegalAccessException if the field is not accessible
-	 */
-	public static void writeField(Object target, String fieldName, Object value)
-			throws IllegalAccessException {
-		writeField(target, fieldName, value, false);
-	}
-
-	/**
-	 * Write a field. Superclasses will be considered.
-	 * 
-	 * @param target the object to reflect, must not be null
-	 * @param fieldName the field name to obtain
-	 * @param value to set
-	 * @param forceAccess whether to break scope restrictions using the
-	 *            <code>setAccessible</code> method. <code>False</code> will
-	 *            only match public fields.
-	 * @throws IllegalArgumentException if <code>target</code> or
-	 *             <code>fieldName</code> is null
-	 * @throws IllegalAccessException if the field is not made accessible
-	 */
-	public static void writeField(Object target, String fieldName, Object value, boolean forceAccess)
-			throws IllegalAccessException {
-		if (target == null) {
-			throw new IllegalArgumentException("target object must not be null");
-		}
-		Class cls = target.getClass();
-		Field field = getField(cls, fieldName, forceAccess);
-		if (field == null) {
-			throw new IllegalArgumentException("Cannot locate declared field " + cls.getName()
-					+ "." + fieldName);
-		}
-		// already forced access above, don't repeat it here:
-		writeField(field, target, value);
-	}
-
-	// Useful member methods
-	private static class MemberUtils {
-
-		private static final int ACCESS_TEST = Modifier.PUBLIC | Modifier.PROTECTED
-				| Modifier.PRIVATE;
-
-		public static void setAccessibleWorkaround(AccessibleObject o) {
-			if (o == null || o.isAccessible()) {
-				return;
-			}
-			Member m = (Member) o;
-			if (Modifier.isPublic(m.getModifiers())
-					&& isPackageAccess(m.getDeclaringClass().getModifiers())) {
-				try {
-					o.setAccessible(true);
-				} catch (SecurityException e) { // NOPMD
-					// ignore in favor of subsequent IllegalAccessException
-				}
-			}
-		}
-
-		/**
-		 * Returns whether a given set of modifiers implies package access.
-		 * 
-		 * @param modifiers to test
-		 * @return true unless package/protected/private modifier detected
-		 */
-		public static boolean isPackageAccess(int modifiers) {
-			return (modifiers & ACCESS_TEST) == 0;
-		}
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/reflect/FuzzyReflection.java

@@ -1,666 +0,0 @@
-/*
- *  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.reflect;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.regex.Pattern;
-
-import org.apache.commons.lang.Validate;
-
-import com.comphenix.protocol.reflect.accessors.Accessors;
-import com.comphenix.protocol.reflect.fuzzy.AbstractFuzzyMatcher;
-import com.comphenix.protocol.reflect.fuzzy.FuzzyMethodContract;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
-
-/**
- * Retrieves fields and methods by signature, not just name.
- * 
- * @author Kristian
- */
-public class FuzzyReflection {
-	// The class we're actually representing
-	private Class<?> source;
-
-	// Whether or not to lookup private members
-	private boolean forceAccess;
-
-	public FuzzyReflection(Class<?> source, boolean forceAccess) {
-		this.source = source;
-		this.forceAccess = forceAccess;
-	}
-	
-	/**
-	 * Retrieves a fuzzy reflection instance from a given class.
-	 * @param source - the class we'll use.
-	 * @return A fuzzy reflection instance.
-	 */
-	public static FuzzyReflection fromClass(Class<?> source) {
-		return fromClass(source, false);
-	}
-	
-	/**
-	 * Retrieves a fuzzy reflection instance from a given class.
-	 * @param source - the class we'll use.
-	 * @param forceAccess - whether or not to override scope restrictions.
-	 * @return A fuzzy reflection instance.
-	 */
-	public static FuzzyReflection fromClass(Class<?> source, boolean forceAccess) {
-		return new FuzzyReflection(source, forceAccess);
-	}
-	
-	/**
-	 * Retrieves a fuzzy reflection instance from an object.
-	 * @param reference - the object we'll use.
-	 * @return A fuzzy reflection instance that uses the class of the given object.
-	 */
-	public static FuzzyReflection fromObject(Object reference) {
-		return new FuzzyReflection(reference.getClass(), false);
-	}
-	
-	/**
-	 * Retrieves a fuzzy reflection instance from an object.
-	 * @param reference - the object we'll use.
-	 * @param forceAccess - whether or not to override scope restrictions.
-	 * @return A fuzzy reflection instance that uses the class of the given object.
-	 */
-	public static FuzzyReflection fromObject(Object reference, boolean forceAccess) {
-		return new FuzzyReflection(reference.getClass(), forceAccess);
-	}
-	
-	/**
-	 * Retrieve the value of the first field of the given type.
-	 * @param <T> Type
-	 * @param instance - the instance to retrieve from.
-	 * @param fieldClass - type of the field to retrieve.
-	 * @param forceAccess - whether or not to look for private and protected fields.
-	 * @return The value of that field.
-	 * @throws IllegalArgumentException If the field cannot be found.
-	 */
-	public static <T> T getFieldValue(Object instance, Class<T> fieldClass, boolean forceAccess) {
-		@SuppressWarnings("unchecked")
-		T result = (T) Accessors.getFieldAccessor(instance.getClass(), fieldClass, forceAccess).get(instance);
-		return result;
-	}
-	
-	/**
-	 * Retrieves the underlying class.
-	 * @return The underlying class.
-	 */
-	public Class<?> getSource() {
-		return source;
-	}
-		
-	/**
-	 * Retrieve the singleton instance of a class, from a method or field.
-	 * @return The singleton instance.
-	 * @throws IllegalStateException If the class has no singleton.
-	 */
-	public Object getSingleton() {
-		Method method = null;
-		Field field = null;
-		
-		try {
-			method = getMethod(
-				FuzzyMethodContract.newBuilder().
-					parameterCount(0).
-					returnDerivedOf(source).
-					requireModifier(Modifier.STATIC).
-					build()
-			);
-		} catch (IllegalArgumentException e) {
-			// Try getting the field instead
-			// Note that this will throw an exception if not found
-			field = getFieldByType("instance", source);
-		}
-
-		// Convert into unchecked exceptions
-		if (method != null) {
-			try {
-				method.setAccessible(true);
-				return method.invoke(null);
-			} catch (Exception e) {
-				throw new RuntimeException("Cannot invoke singleton method " + method, e);
-			}
-		}
-		if (field != null) {
-			try {
-				field.setAccessible(true);
-				return field.get(null);
-			} catch (Exception e) {
-				throw new IllegalArgumentException("Cannot get content of singleton field " + field, e);
-			}
-		}
-		// We should never get to this point
-		throw new IllegalStateException("Impossible.");
-	}
-	
-	/**
-	 * Retrieve the first method that matches.
-	 * <p>
-	 * ForceAccess must be TRUE in order for this method to access private, protected and package level method.
-	 * @param matcher - the matcher to use.
-	 * @return The first method that satisfies the given matcher.
-	 * @throws IllegalArgumentException If the method cannot be found.
-	 */
-	public Method getMethod(AbstractFuzzyMatcher<MethodInfo> matcher) {
-		List<Method> result = getMethodList(matcher);
-
-		if (result.size() > 0) {
-			return result.get(0);
-		} else {
-			throw new IllegalArgumentException("Unable to find a method that matches " + matcher);
-		}
-	}
-
-	/**
-	 * Retrieve a method that matches. If there are multiple methods that match, the first one with the preferred
-	 * name is selected.
-	 * <p>
-	 * ForceAccess must be TRUE in order for this method to access private, protected and package level method.
-	 * @param matcher - the matcher to use.
-	 * @param preferred - the preferred name.
-	 * @return The first method that satisfies the given matcher.
-	 * @throws IllegalArgumentException If the method cannot be found.
-	 */
-	public Method getMethod(AbstractFuzzyMatcher<MethodInfo> matcher, String preferred) {
-		List<Method> result = getMethodList(matcher);
-
-		if (result.size() > 1) {
-			for (Method method : result) {
-				if (method.getName().equals(preferred)) {
-					return method;
-				}
-			}
-		}
-
-		if (result.size() > 0) {
-			return result.get(0);
-		} else {
-			throw new IllegalArgumentException("Unable to find a method that matches " + matcher);
-		}
-	}
-
-	/**
-	 * Retrieve a list of every method that matches the given matcher.
-	 * <p>
-	 * ForceAccess must be TRUE in order for this method to access private, protected and package level methods.
-	 * @param matcher - the matcher to apply.
-	 * @return List of found methods.
-	 */
-	public List<Method> getMethodList(AbstractFuzzyMatcher<MethodInfo> matcher) {
-		List<Method> methods = Lists.newArrayList();
-		
-		// Add all matching fields to the list
-		for (Method method : getMethods()) {
-			if (matcher.isMatch(MethodInfo.fromMethod(method), source)) {
-				methods.add(method);
-			}
-		}
-		return methods;
-	}
-	
-	/**
-	 * Retrieves a method by looking at its name.
-	 * @param nameRegex -  regular expression that will match method names.
-	 * @return The first method that satisfies the regular expression.
-	 * @throws IllegalArgumentException If the method cannot be found.
-	 */
-	public Method getMethodByName(String nameRegex) {
-		Pattern match = Pattern.compile(nameRegex);
-		
-		for (Method method : getMethods()) {
-			if (match.matcher(method.getName()).matches()) {
-				// Right - this is probably it.
-				return method;
-			}
-		}
-
-		throw new IllegalArgumentException("Unable to find a method with the pattern " +
-									nameRegex + " in " + source.getName());
-	}
-	
-	/**
-	 * Retrieves a method by looking at the parameter types only.
-	 * @param name - potential name of the method. Only used by the error mechanism.
-	 * @param args - parameter types of the method to find.
-	 * @return The first method that satisfies the parameter types.
-	 * @throws IllegalArgumentException If the method cannot be found.
-	 */
-	public Method getMethodByParameters(String name, Class<?>... args) {
-		// Find the correct method to call
-		for (Method method : getMethods()) {
-			if (Arrays.equals(method.getParameterTypes(), args)) {
-				return method;
-			}
-		}
-		
-		// That sucks
-		throw new IllegalArgumentException("Unable to find " + name + " in " + source.getName());
-	}
-	
-	/**
-	 * Retrieves a method by looking at the parameter types and return type only.
-	 * @param name - potential name of the method. Only used by the error mechanism.
-	 * @param returnType - return type of the method to find.
-	 * @param args - parameter types of the method to find.
-	 * @return The first method that satisfies the parameter types.
-	 * @throws IllegalArgumentException If the method cannot be found.
-	 */
-	public Method getMethodByParameters(String name, Class<?> returnType, Class<?>[] args) {
-		// Find the correct method to call
-		List<Method> methods = getMethodListByParameters(returnType, args);
-		
-		if (methods.size() > 0) {
-			return methods.get(0);
-		} else {
-			// That sucks
-			throw new IllegalArgumentException("Unable to find " + name + " in " + source.getName());
-		}
-	}
-	
-	/**
-	 * Retrieves a method by looking at the parameter types and return type only.
-	 * @param name - potential name of the method. Only used by the error mechanism.
-	 * @param returnTypeRegex - regular expression matching the return type of the method to find.
-	 * @param argsRegex - regular expressions of the matching parameter types.
-	 * @return The first method that satisfies the parameter types.
-	 * @throws IllegalArgumentException If the method cannot be found.
-	 */
-	public Method getMethodByParameters(String name, String returnTypeRegex, String[] argsRegex) {
-		Pattern match = Pattern.compile(returnTypeRegex);
-		Pattern[] argMatch = new Pattern[argsRegex.length];
-		
-		for (int i = 0; i < argsRegex.length; i++) {
-			argMatch[i] = Pattern.compile(argsRegex[i]);
-		}
-		
-		// Find the correct method to call
-		for (Method method : getMethods()) {
-			if (match.matcher(method.getReturnType().getName()).matches()) {
-				if (matchParameters(argMatch, method.getParameterTypes()))
-					return method;
-			}
-		}
-		
-		// That sucks
-		throw new IllegalArgumentException("Unable to find " + name + " in " + source.getName());
-	}
-	
-	/**
-	 * Invoke a method by return type and parameters alone.
-	 * <p>
-	 * The parameters must be non-null for this to work.
-	 * @param target - the instance.
-	 * @param name - the name of the method - for debugging.
-	 * @param returnType - the expected return type.
-	 * @param parameters - the parameters.
-	 * @return The return value, or NULL.
-	 */
-	public Object invokeMethod(Object target, String name, Class<?> returnType, Object... parameters) {
-		Class<?>[] types = new Class<?>[parameters.length];
-		
-		for (int i = 0; i < types.length; i++) {
-			types[i] = parameters[i].getClass();
-		}
-		return Accessors.getMethodAccessor(getMethodByParameters(name, returnType, types)).
-			invoke(target, parameters);
-	}
-	
-	private boolean matchParameters(Pattern[] parameterMatchers, Class<?>[] argTypes) {
-		if (parameterMatchers.length != argTypes.length)
-			throw new IllegalArgumentException("Arrays must have the same cardinality.");
-		
-		// Check types against the regular expressions
-		for (int i = 0; i < argTypes.length; i++) {
-			if (!parameterMatchers[i].matcher(argTypes[i].getName()).matches())
-				return false;
-		}
-		
-		return true;
-	}
-	
-	/**
-	 * Retrieves every method that has the given parameter types and return type.
-	 * @param returnType - return type of the method to find.
-	 * @param args - parameter types of the method to find.
-	 * @return Every method that satisfies the given constraints.
-	 */
-	public List<Method> getMethodListByParameters(Class<?> returnType, Class<?>[] args) {
-		List<Method> methods = new ArrayList<Method>();
-		
-		// Find the correct method to call
-		for (Method method : getMethods()) {
-			if (method.getReturnType().equals(returnType) && Arrays.equals(method.getParameterTypes(), args)) {
-				methods.add(method);
-			}
-		}
-		return methods;
-	}
-	
-	/**
-	 * Retrieves a field by name.
-	 * @param nameRegex - regular expression that will match a field name.
-	 * @return The first field to match the given expression.
-	 * @throws IllegalArgumentException If the field cannot be found.
-	 */
-	public Field getFieldByName(String nameRegex) {
-		Pattern match = Pattern.compile(nameRegex);
-		
-		for (Field field : getFields()) {
-			if (match.matcher(field.getName()).matches()) {
-				// Right - this is probably it.
-				return field;
-			}
-		}
-		
-		// Looks like we're outdated. Too bad.
-		throw new IllegalArgumentException("Unable to find a field with the pattern " +
-									nameRegex + " in " + source.getName());
-	}
-	
-	/**
-	 * Retrieves the first field with a type equal to or more specific to the given type.
-	 * @param name - name the field probably is given. This will only be used in the error message.
-	 * @param type - type of the field to find.
-	 * @return The first field with a type that is an instance of the given type.
-	 */
-	public Field getFieldByType(String name, Class<?> type) {
-		List<Field> fields = getFieldListByType(type);
-		
-		if (fields.size() > 0) {
-			return fields.get(0);
-		} else {
-			// Looks like we're outdated. Too bad.
-			throw new IllegalArgumentException(String.format("Unable to find a field %s with the type %s in %s",
-					name, type.getName(), source.getName())
-			);
-		}
-	}
-	
-	/**
-	 * Retrieves every field with a type equal to or more specific to the given type.
-	 * @param type - type of the fields to find.
-	 * @return Every field with a type that is an instance of the given type.
-	 */
-	public List<Field> getFieldListByType(Class<?> type) {
-		List<Field> fields = new ArrayList<Field>();
-		
-		// Field with a compatible type
-		for (Field field : getFields()) {
-			// A assignable from B -> B instanceOf A
-			if (type.isAssignableFrom(field.getType())) {
-				fields.add(field);
-			}
-		}
-		
-		return fields;
-	}
-	
-	/**
-	 * Retrieve the first field that matches.
-	 * <p>
-	 * ForceAccess must be TRUE in order for this method to access private, protected and package level fields.
-	 * @param matcher - the matcher to use.
-	 * @return The first method that satisfies the given matcher.
-	 * @throws IllegalArgumentException If the method cannot be found.
-	 */
-	public Field getField(AbstractFuzzyMatcher<Field> matcher) {
-		List<Field> result = getFieldList(matcher);
-		
-		if (result.size() > 0)
-			return result.get(0);
-		else
-			throw new IllegalArgumentException("Unable to find a field that matches " + matcher);
-	}
-	
-	/**
-	 * Retrieve a list of every field that matches the given matcher.
-	 * <p>
-	 * ForceAccess must be TRUE in order for this method to access private, protected and package level fields.
-	 * @param matcher - the matcher to apply.
-	 * @return List of found fields.
-	 */
-	public List<Field> getFieldList(AbstractFuzzyMatcher<Field> matcher) {
-		List<Field> fields = Lists.newArrayList();
-		
-		// Add all matching fields to the list
-		for (Field field : getFields()) {
-			if (matcher.isMatch(field, source)) {
-				fields.add(field);
-			}
-		}
-		return fields;
-	}
-	
-	/**
-	 * Retrieves a field by type.
-	 * <p>
-	 * Note that the type is matched using the full canonical representation, i.e.:
-	 * <ul>
-	 *     <li>java.util.List</li>
-	 *     <li>net.comphenix.xp.ExperienceMod</li>
-	 * </ul>
-	 * @param typeRegex - regular expression that will match the field type.
-	 * @return The first field with a type that matches the given regular expression.
-	 * @throws IllegalArgumentException If the field cannot be found.
-	 */
-	public Field getFieldByType(String typeRegex) {
-		
-		Pattern match = Pattern.compile(typeRegex);
-		
-		// Like above, only here we test the field type
-		for (Field field : getFields()) {
-			String name = field.getType().getName();
-			
-			if (match.matcher(name).matches()) {
-				return field;
-			}
-		}
-		
-		// Looks like we're outdated. Too bad.
-		throw new IllegalArgumentException("Unable to find a field with the type " +
-										   typeRegex + " in " + source.getName());
-	}
-	
-	/**
-	 * Retrieves a field by type.
-	 * <p>
-	 * Note that the type is matched using the full canonical representation, i.e.:
-	 * <ul>
-	 *     <li>java.util.List</li>
-	 *     <li>net.comphenix.xp.ExperienceMod</li>
-	 * </ul>
-	 * @param typeRegex - regular expression that will match the field type.
-	 * @param ignored - types to ignore.
-	 * @return The first field with a type that matches the given regular expression.
-	 * @throws IllegalArgumentException If the field cannot be found.
-	 */
-	@SuppressWarnings("rawtypes")
-	public Field getFieldByType(String typeRegex, Set<Class> ignored) {
-		
-		Pattern match = Pattern.compile(typeRegex);
-		
-		// Like above, only here we test the field type
-		for (Field field : getFields()) {
-			Class type = field.getType();
-			
-			if (!ignored.contains(type) && match.matcher(type.getName()).matches()) {
-				return field;
-			}
-		}
-		
-		// Looks like we're outdated. Too bad.
-		throw new IllegalArgumentException("Unable to find a field with the type " +
-									       typeRegex + " in " + source.getName());
-	}
-	
-	/**
-	 * Retrieve the first constructor that matches.
-	 * <p>
-	 * ForceAccess must be TRUE in order for this method to access private, protected and package level constructors.
-	 * @param matcher - the matcher to use.
-	 * @return The first constructor that satisfies the given matcher.
-	 * @throws IllegalArgumentException If the constructor cannot be found.
-	 */
-	public Constructor<?> getConstructor(AbstractFuzzyMatcher<MethodInfo> matcher) {
-		List<Constructor<?>> result = getConstructorList(matcher);
-		
-		if (result.size() > 0)
-			return result.get(0);
-		else
-			throw new IllegalArgumentException("Unable to find a method that matches " + matcher);
-	}
-	
-	/**
-	 * Retrieve every method as a map over names.
-	 * <p>
-	 * Note that overloaded methods will only occur once in the resulting map.
-	 * @param methods - every method.
-	 * @return A map over every given method.
-	 */
-	public Map<String, Method> getMappedMethods(List<Method> methods) {
-		Map<String, Method> map = Maps.newHashMap();
-		
-		for (Method method : methods) {
-			map.put(method.getName(), method);
-		}
-		return map;
-	}
-	
-	/**
-	 * Retrieve a list of every constructor that matches the given matcher.
-	 * <p>
-	 * ForceAccess must be TRUE in order for this method to access private, protected and package level constructors.
-	 * @param matcher - the matcher to apply.
-	 * @return List of found constructors.
-	 */
-	public List<Constructor<?>> getConstructorList(AbstractFuzzyMatcher<MethodInfo> matcher) {
-		List<Constructor<?>> constructors = Lists.newArrayList();
-		
-		// Add all matching fields to the list
-		for (Constructor<?> constructor : getConstructors()) {
-			if (matcher.isMatch(MethodInfo.fromConstructor(constructor), source)) {
-				constructors.add(constructor);
-			}
-		}
-		return constructors;
-	}
-	
-	/**
-	 * Retrieves all private and public fields in declared order (after JDK 1.5).
-	 * <p>
-	 * Private, protected and package fields are ignored if forceAccess is FALSE.
-	 * @return Every field.
-	 */
-	public Set<Field> getFields() {
-		Validate.notNull(source, "source cannot be null!");
-
-		// We will only consider private fields in the declared class
-		if (forceAccess)
-			return setUnion(source.getDeclaredFields(), source.getFields());
-		else
-			return setUnion(source.getFields());
-	}
-	
-	/**
-	 * Retrieves all private and public fields, up until a certain superclass.
-	 * @param excludeClass - the class (and its superclasses) to exclude from the search.
-	 * @return Every such declared field.
-	 */
-	public Set<Field> getDeclaredFields(Class<?> excludeClass) {
-		if (forceAccess) {
-			Class<?> current = source;
-			Set<Field> fields = Sets.newLinkedHashSet();
-			
-			while (current != null && current != excludeClass) {
-				fields.addAll(Arrays.asList(current.getDeclaredFields()));
-				current = current.getSuperclass();
-			}
-			return fields;
-		}
-		return getFields();
-	}
-	
-	/**
-	 * Retrieves all private and public methods in declared order (after JDK 1.5).
-	 * <p>
-	 * Private, protected and package methods are ignored if forceAccess is FALSE.
-	 * @return Every method.
-	 */
-	public Set<Method> getMethods() {
-		// We will only consider private methods in the declared class
-		if (forceAccess)
-			return setUnion(source.getDeclaredMethods(), source.getMethods());
-		else
-			return setUnion(source.getMethods());
-	}
-	
-	/**
-	 * Retrieves all private and public constructors in declared order (after JDK 1.5).
-	 * <p>
-	 * Private, protected and package constructors are ignored if forceAccess is FALSE.
-	 * @return Every constructor.
-	 */
-	public Set<Constructor<?>> getConstructors() {
-		if (forceAccess)
-			return setUnion(source.getDeclaredConstructors());
-		else
-			return setUnion(source.getConstructors());
-	}
-	
-	// Prevent duplicate fields
-
-	@SafeVarargs
-	private static <T> Set<T> setUnion(T[]... array) {
-		Set<T> result = new LinkedHashSet<T>();
-		
-		for (T[] elements : array) {
-			for (T element : elements) {
-				result.add(element);
-			}
-		}
-		return result;
-	}
-	
-	/**
-	 * Retrieves whether or not not to override any scope restrictions.
-	 * @return TRUE if we override scope, FALSE otherwise.
-	 */
-	public boolean isForceAccess() {
-		return forceAccess;
-	}
-
-	/**
-	 * Sets whether or not not to override any scope restrictions.
-	 * @param forceAccess - TRUE if we override scope, FALSE otherwise.
-	 */
-	public void setForceAccess(boolean forceAccess) {
-		this.forceAccess = forceAccess;
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/reflect/IntEnum.java

@@ -1,106 +0,0 @@
-/*
- *  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.reflect;
-
-import java.lang.reflect.Field;
-import java.util.HashSet;
-import java.util.Set;
-
-import com.google.common.collect.BiMap;
-import com.google.common.collect.HashBiMap;
-
-/**
- * Represents a traditional int field enum.
- * 
- * @author Kristian
- */
-public class IntEnum {
-
-	// Used to convert between IDs and names
-	protected BiMap<Integer, String> members = HashBiMap.create();
-	
-	/**
-	 * Registers every declared integer field.
-	 */
-	public IntEnum() {
-		registerAll();
-	}
-	
-	/**
-	 * Registers every public int field as a member.
-	 */
-	protected void registerAll() {
-		try {
-			// Register every int field
-			for (Field entry : this.getClass().getFields()) {
-				if (entry.getType().equals(int.class)) {
-					registerMember(entry.getInt(this), entry.getName());
-				}
-			}
-		
-		} catch (IllegalArgumentException e) {
-			e.printStackTrace();
-		} catch (IllegalAccessException e) {
-			e.printStackTrace();
-		}
-	}
-	
-	/**
-	 * Registers a member.
-	 * @param id - id of member.
-	 * @param name - name of member.
-	 */
-	protected void registerMember(int id, String name) {
-		members.put(id, name);
-	}
-	
-	/**
-	 * Determines whether or not the given member exists.
-	 * @param id - the ID of the member to find.
-	 * @return TRUE if a member with the given ID exists, FALSE otherwise.
-	 */
-	public boolean hasMember(int id) {
-		return members.containsKey(id);
-	}
-	
-	/**
-	 * Retrieve the ID of the member with the given name.
-	 * @param name - name of member to retrieve.
-	 * @return ID of the member, or NULL if not found.
-	 */
-	public Integer valueOf(String name) {
-		return members.inverse().get(name);
-	}
-	
-	/**
-	 * Retrieve the name of the member with the given id.
-	 * @param id - id of the member to retrieve.
-	 * @return Declared name of the member, or NULL if not found.
-	 */
-	public String getDeclaredName(Integer id) {
-		return members.get(id);
-	}
-	
-	/**
-	 * Retrieve the ID of every registered member.
-	 * @return Enumeration of every value.
-	 */
-	public Set<Integer> values() {
-		return new HashSet<Integer>(members.keySet());
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/reflect/MethodInfo.java

@@ -1,258 +0,0 @@
-package com.comphenix.protocol.reflect;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.GenericDeclaration;
-import java.lang.reflect.Member;
-import java.lang.reflect.Method;
-import java.lang.reflect.TypeVariable;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
-
-import com.google.common.collect.Lists;
-
-/**
- * Represents a method or a constructor.
- * 
- * @author Kristian
- */
-@SuppressWarnings("unused") // Java 8 compat
-public abstract class MethodInfo implements GenericDeclaration, Member {
-	/**
-	 * Wraps a method as a MethodInfo object.
-	 * @param method - the method to wrap.
-	 * @return The wrapped method.
-	 */
-	public static MethodInfo fromMethod(final Method method) {
-		return new MethodInfo() {
-			// @Override
-			public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
-				return method.getAnnotation(annotationClass);
-			}
-			// @Override
-			public Annotation[] getAnnotations() {
-				return method.getAnnotations();
-			}
-			// @Override
-			public Annotation[] getDeclaredAnnotations() {
-				return method.getDeclaredAnnotations();
-			}
-			@Override
-			public String getName() {
-				return method.getName();
-			}
-			@Override
-			public Class<?>[] getParameterTypes() {
-				return method.getParameterTypes();
-			}
-			@Override
-			public Class<?> getDeclaringClass() {
-				return method.getDeclaringClass();
-			}
-			@Override
-			public Class<?> getReturnType() {
-				return method.getReturnType();
-			}
-			@Override
-			public int getModifiers() {
-				return method.getModifiers();
-			}
-			@Override
-			public Class<?>[] getExceptionTypes() {
-				return method.getExceptionTypes();
-			}
-			@Override
-			public TypeVariable<?>[] getTypeParameters() {
-				return method.getTypeParameters();
-			}
-			@Override
-			public String toGenericString() {
-				return method.toGenericString();
-			}
-			@Override
-			public String toString() {
-				return method.toString();
-			}
-			@Override
-			public boolean isSynthetic() {
-				return method.isSynthetic();
-			}
-			@Override
-			public int hashCode() {
-				return method.hashCode();
-			}
-			@Override
-			public boolean isConstructor() {
-				return false;
-			}
-		};
-	}
-	
-	/**
-	 * Construct a list of method infos from a given array of methods.
-	 * @param methods - array of methods.
-	 * @return Method info list.
-	 */
-	public static Collection<MethodInfo> fromMethods(Method[] methods) {
-		return fromMethods(Arrays.asList(methods));
-	}
-
-	/**
-	 * Construct a list of method infos from a given collection of methods.
-	 * @param methods - list of methods.
-	 * @return Method info list.
-	 */
-	public static List<MethodInfo> fromMethods(Collection<Method> methods) {
-		List<MethodInfo> infos = Lists.newArrayList();
-		
-		for (Method method : methods)
-			infos.add(fromMethod(method));
-		return infos;
-	}
-	
-	/**
-	 * Wraps a constructor as a method information object.
-	 * @param constructor - the constructor to wrap.
-	 * @return A wrapped constructor.
-	 */
-	public static MethodInfo fromConstructor(final Constructor<?> constructor) {
-		return new MethodInfo() {
-			// @Override
-			public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
-				return constructor.getAnnotation(annotationClass);
-			}
-			// @Override
-			public Annotation[] getAnnotations() {
-				return constructor.getAnnotations();
-			}
-			// @Override
-			public Annotation[] getDeclaredAnnotations() {
-				return constructor.getDeclaredAnnotations();
-			}
-			@Override
-			public String getName() {
-				return constructor.getName();
-			}
-			@Override
-			public Class<?>[] getParameterTypes() {
-				return constructor.getParameterTypes();
-			}
-			@Override
-			public Class<?> getDeclaringClass() {
-				return constructor.getDeclaringClass();
-			}
-			@Override
-			public Class<?> getReturnType() {
-				return Void.class;
-			}
-			@Override
-			public int getModifiers() {
-				return constructor.getModifiers();
-			}
-			@Override
-			public Class<?>[] getExceptionTypes() {
-				return constructor.getExceptionTypes();
-			}
-			@Override
-			public TypeVariable<?>[] getTypeParameters() {
-				return constructor.getTypeParameters();
-			}
-			@Override
-			public String toGenericString() {
-				return constructor.toGenericString();
-			}
-			@Override
-			public String toString() {
-				return constructor.toString();
-			}
-			@Override
-			public boolean isSynthetic() {
-				return constructor.isSynthetic();
-			}
-			@Override
-			public int hashCode() {
-				return constructor.hashCode();
-			}
-			@Override
-			public boolean isConstructor() {
-				return true;
-			}
-		};
-	}
-	
-	/**
-	 * Construct a list of method infos from a given array of constructors.
-	 * @param constructors - array of constructors.
-	 * @return Method info list.
-	 */
-	public static Collection<MethodInfo> fromConstructors(Constructor<?>[] constructors) {
-		return fromConstructors(Arrays.asList(constructors));
-	}
-	
-	/**
-	 * Construct a list of method infos from a given collection of constructors.
-	 * @param constructors - list of constructors.
-	 * @return Method info list.
-	 */
-	public static List<MethodInfo> fromConstructors(Collection<Constructor<?>> constructors) {
-		List<MethodInfo> infos = Lists.newArrayList();
-		
-		for (Constructor<?> constructor : constructors)
-			infos.add(fromConstructor(constructor));
-		return infos;
-	}
-	
-	/**
-	 * Returns a string describing this method or constructor
-	 * @return A string representation of the object.
-	 * @see Method#toString()
-	 * @see Constructor#toString()
-	 */
-	@Override
-	public String toString() {
-		throw new UnsupportedOperationException();
-	}
-
-	/**
-	 * Returns a string describing this method or constructor, including type parameters.
-	 * @return A string describing this Method, include type parameters
-	 * @see Method#toGenericString()
-	 * @see Constructor#toGenericString()
-	 */
-	public abstract String toGenericString();
-	
-	/**
-	 * Returns an array of Class objects that represent the types of the exceptions declared to be thrown by the
-	 * underlying method or constructor represented by this MethodInfo object.
-	 * @return The exception types declared as being thrown by the method or constructor this object represents.
-	 * @see Method#getExceptionTypes()
-	 * @see Constructor#getExceptionTypes()
-	 */
-	public abstract Class<?>[] getExceptionTypes();
-
-	/**
-	 * Returns a Class object that represents the formal return type of the method or constructor
-	 * represented by this MethodInfo object.
-	 * <p>
-	 * This is always {@link Void} for constructors.
-	 * @return The return value, or Void if a constructor.
-	 * @see Method#getReturnType()
-	 */
-	public abstract Class<?> getReturnType();
-
-	/**
-	 * Returns an array of Class objects that represent the formal parameter types, in declaration order,
-	 * of the method or constructor represented by this MethodInfo object.
-	 * @return The parameter types for the method or constructor this object represents.
-	 * @see Method#getParameterTypes()
-	 * @see Constructor#getParameterTypes()
-	 */
-	public abstract Class<?>[] getParameterTypes();
-	
-	/**
-	 * Determine if this is a constructor or not.
-	 * @return TRUE if this represents a constructor, FALSE otherwise.
-	 */
-	public abstract boolean isConstructor();
-}

modules/API/src/main/java/com/comphenix/protocol/reflect/ObjectEnum.java

@@ -1,126 +0,0 @@
-/*
- *  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.reflect;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.Set;
-
-import com.google.common.collect.BiMap;
-import com.google.common.collect.HashBiMap;
-
-/**
- * Represents a more modern object-based enum.
- * <p>
- * This is useful if you want the flexibility of a modern Java enum, but don't
- * want to prevent the creation of additional members dynamically.
- * @author Kristian
- */
-public class ObjectEnum<T> implements Iterable<T> {
-	// Used to convert between IDs and names
-	protected BiMap<T, String> members = HashBiMap.create();
-
-	/**
-	 * Registers every declared integer field.
-	 * @param fieldType Field type
-	 */
-	public ObjectEnum(Class<T> fieldType) {
-		registerAll(fieldType);
-	}
-
-	/**
-	 * Registers every public assignable static field as a member.
-	 * @param fieldType Field type
-	 */
-	@SuppressWarnings("unchecked")
-	protected void registerAll(Class<T> fieldType) {
-		try {
-			// Register every non-deprecated field
-			for (Field entry : this.getClass().getFields()) {
-				if (Modifier.isStatic(entry.getModifiers()) && fieldType.isAssignableFrom(entry.getType())) {
-					T value = (T) entry.get(null);
-					
-					if (value == null)
-						throw new IllegalArgumentException("Field " + entry + " was NULL. Remember to " +
-								"construct the object after the field has been declared.");
-					registerMember(value, entry.getName());
-				}
-			}
-		} catch (IllegalArgumentException e) {
-			e.printStackTrace();
-		} catch (IllegalAccessException e) {
-			e.printStackTrace();
-		}
-	}
-	
-	/**
-	 * Registers a member if its not present.
-	 * @param instance - member instance.
-	 * @param name - name of member.
-	 * @return TRUE if the member was registered, FALSE otherwise.
-	 */
-	public boolean registerMember(T instance, String name) {
-		if (!members.containsKey(instance)) {
-			members.put(instance, name);
-			return true;
-		}
-		return false;
-	}
-	
-	/**
-	 * Determines whether or not the given member has been registered to this enum.
-	 * @param member - the member to check.
-	 * @return TRUE if the given member has been registered, FALSE otherwise.
-	 */
-	public boolean hasMember(T member) {
-		return members.containsKey(member);
-	}
-	
-	/**
-	 * Retrieve a member by name,
-	 * @param name - name of member to retrieve.
-	 * @return The member, or NULL if not found.
-	 */
-	public T valueOf(String name) {
-		return members.inverse().get(name);
-	}
-	
-	/**
-	 * Retrieve the name of the given member.
-	 * @param member - the member to retrieve.
-	 * @return Declared name of the member, or NULL if not found.
-	 */
-	public String getDeclaredName(T member) {
-		return members.get(member);
-	}
-	
-	/**
-	 * Retrieve every registered member.
-	 * @return Enumeration of every value.
-	 */
-	public Set<T> values() {
-		return new HashSet<T>(members.keySet());
-	}
-
-	@Override
-	public Iterator<T> iterator() {
-		return members.keySet().iterator();
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/reflect/ObjectWriter.java

@@ -1,130 +0,0 @@
-/*
- *  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.reflect;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-
-import com.comphenix.protocol.injector.StructureCache;
-import com.comphenix.protocol.utility.MinecraftReflection;
-
-/**
- * Can copy an object field by field.
- * 
- * @author Kristian
- */
-public class ObjectWriter {
-	// Cache structure modifiers
-	@SuppressWarnings("rawtypes")
-	private static ConcurrentMap<Class, StructureModifier<Object>> cache =
-			new ConcurrentHashMap<Class, StructureModifier<Object>>();
-	
-	/**
-	 * Retrieve a usable structure modifier for the given object type.
-	 * <p>
-	 * Will attempt to reuse any other structure modifiers we have cached.
-	 * @param type - the type of the object we are modifying.
-	 * @return A structure modifier for the given type.
-	 */
-	private StructureModifier<Object> getModifier(Class<?> type) {
-		Class<?> packetClass = MinecraftReflection.getPacketClass();
-		
-		// Handle subclasses of the packet class with our custom structure cache
-		if (!type.equals(packetClass) && packetClass.isAssignableFrom(type)) {
-			// Delegate to our already existing registry of structure modifiers
-			return StructureCache.getStructure(type);
-		}
-		
-		StructureModifier<Object> modifier = cache.get(type);
-		
-		// Create the structure modifier if we haven't already
-		if (modifier == null) {
-			StructureModifier<Object> value = new StructureModifier<Object>(type, null, false);
-			modifier = cache.putIfAbsent(type, value);
-			
-			if (modifier == null)
-				modifier = value;
-		}
-		
-		// And we're done
-		return modifier;
-	}
-	
-	/**
-	 * Copy every field in object A to object B. Each value is copied directly, and is not cloned.
-	 * <p>
-	 * The two objects must have the same number of fields of the same type.
-	 * @param source - fields to copy.
-	 * @param destination - fields to copy to.
-	 * @param commonType - type containing each field to copy.
-	 */
-	public void copyTo(Object source, Object destination, Class<?> commonType) {
-		// Note that we indicate that public fields will be copied the first time around
-		copyToInternal(source, destination, commonType, true);
-	}
-
-	/**
-	 * Called for every non-static field that will be copied.
-	 * @param modifierSource - modifier for the original object.
-	 * @param modifierDest - modifier for the new cloned object.
-	 * @param fieldIndex - the current field index.
-	 */
-	protected void transformField(StructureModifier<Object> modifierSource, StructureModifier<Object> modifierDest, int fieldIndex) {
-		Object value = modifierSource.read(fieldIndex);
-		modifierDest.write(fieldIndex, value);
-	}
-	
-	// Internal method that will actually implement the recursion
-	private void copyToInternal(Object source, Object destination, Class<?> commonType, boolean copyPublic) {
-		if (source == null)
-			throw new IllegalArgumentException("Source cannot be NULL");
-		if (destination == null)
-			throw new IllegalArgumentException("Destination cannot be NULL");
-		
-		StructureModifier<Object> modifier = getModifier(commonType);
-		
-		// Add target
-		StructureModifier<Object> modifierSource = modifier.withTarget(source);
-		StructureModifier<Object> modifierDest = modifier.withTarget(destination);
-		
-		// Copy every field
-		try {
-			for (int i = 0; i < modifierSource.size(); i++) {
-				Field field = modifierSource.getField(i);
-				int mod = field.getModifiers();
-				
-				// Skip static fields. We also get the "public" fields fairly often, so we'll skip that.
-				if (!Modifier.isStatic(mod) && (!Modifier.isPublic(mod) || copyPublic)) {
-					transformField(modifierSource, modifierDest, i);
-				}
-			}
-			
-			// Copy private fields underneath
-			Class<?> superclass = commonType.getSuperclass();
-			
-			if (superclass != null && !superclass.equals(Object.class)) {
-				copyToInternal(source, destination, superclass, false);
-			}
-			
-		} catch (FieldAccessException e) {
-			throw new RuntimeException("Unable to copy fields from " + commonType.getName(), e);
-		}
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/reflect/PrettyPrinter.java

@@ -1,289 +0,0 @@
-/*
- *  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.reflect;
-
-import java.lang.reflect.Array;
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-
-import com.google.common.primitives.Primitives;
-
-/**
- * Used to print the content of an arbitrary class.
- * 
- * @author Kristian
- */
-public class PrettyPrinter {
-	/**
-	 * Represents a generic object printer.
-	 * @author Kristian
-	 */
-	public interface ObjectPrinter {
-		public static final ObjectPrinter DEFAULT = new ObjectPrinter() {
-			@Override
-			public boolean print(StringBuilder output, Object value) {
-				return false;
-			}
-		};
-		
-		/**
-		 * Print the content of the given object.
-		 * <p>
-		 * Return FALSE in order for let the default printer take over.
-		 * @param output - where to print the output.
-		 * @param value - the value to print, may be NULL.
-		 * @return TRUE if we processed the value and added to the output, FALSE otherwise.
-		 */
-		public boolean print(StringBuilder output, Object value);
-	}
-	
-	/**
-	 * How far we will recurse.
-	 */
-	public final static int RECURSE_DEPTH = 3;
-
-	/**
-	 * Print the contents of an object.
-	 * @param object - the object to serialize.
-	 * @return String representation of the class.
-	 * @throws IllegalAccessException If the object is null
-	 */
-	public static String printObject(Object object) throws IllegalAccessException {
-		if (object == null)
-			throw new IllegalArgumentException("object cannot be NULL.");
-		
-		return printObject(object, object.getClass(), Object.class);
-	}
-	
-	/**
-	 * Print the contents of an object.
-	 * @param object - the object to serialize.
-	 * @param start - class to start at.
-	 * @param stop - superclass that will stop the process.
-	 * @return String representation of the class
-	 * @throws IllegalAccessException If the object is null
-	 */
-	public static String printObject(Object object, Class<?> start, Class<?> stop) throws IllegalAccessException {
-		if (object == null)
-			throw new IllegalArgumentException("object cannot be NULL.");
-		
-		return printObject(object, start, stop, RECURSE_DEPTH);
-	}
-	
-	/**
-	 * Print the contents of an object.
-	 * @param object - the object to serialize.
-	 * @param start - class to start at.
-	 * @param stop - superclass that will stop the process.
-	 * @param hierachyDepth - maximum recursion level.
-	 * @return String representation of the class.
-	 * @throws IllegalAccessException If the object is null
-	 */
-	public static String printObject(Object object, Class<?> start, Class<?> stop, int hierachyDepth) throws IllegalAccessException {
-		return printObject(object, start, stop, hierachyDepth, ObjectPrinter.DEFAULT);
-	}
-	
-	/**
-	 * Print the contents of an object.
-	 * @param object - the object to serialize.
-	 * @param start - class to start at.
-	 * @param stop - superclass that will stop the process.
-	 * @param hierachyDepth - maximum recursion level.
-	 * @param printer - a generic object printer.
-	 * @return String representation of the class.
-	 * @throws IllegalAccessException If the object is null
-	 */
-	public static String printObject(Object object, Class<?> start, Class<?> stop, int hierachyDepth, ObjectPrinter printer) throws IllegalAccessException {
-		if (object == null)
-			throw new IllegalArgumentException("object cannot be NULL.");
-		
-		StringBuilder output = new StringBuilder();
-		Set<Object> previous = new HashSet<Object>();
-		
-		// Start and stop
-		output.append("{ ");
-		printObject(output, object, start, stop, previous, hierachyDepth, true, printer);
-		output.append(" }");
-		
-		return output.toString();
-	}
-	
-	@SuppressWarnings("rawtypes")
-	private static void printIterables(StringBuilder output, Iterable iterable, Class<?> stop,
-									   Set<Object> previous, int hierachyIndex, ObjectPrinter printer) throws IllegalAccessException {
-		
-		boolean first = true;
-		output.append("(");
-		
-		for (Object value : iterable) {
-			if (first)
-				first = false;
-			else
-				output.append(", ");
-			
-			// Print value
-			printValue(output, value,  stop, previous, hierachyIndex - 1, printer);
-		}
-		
-		output.append(")");
-	}
-
-	/**
-	 * Print the content of a maps entries.
-	 * @param output - the output string builder.
-	 * @param map - the map to print.
-	 * @param current - the type of this map.
-	 * @param stop - the class that indicates we should stop printing.
-	 * @param previous - previous objects printed.
-	 * @param hierachyIndex - hierachy index.
-	 * @throws IllegalAccessException If any reflection went wrong.
-	 */
-	private static void printMap(StringBuilder output, Map<Object, Object> map, Class<?> current, Class<?> stop,
-			   Set<Object> previous, int hierachyIndex, ObjectPrinter printer) throws IllegalAccessException {
-
-		boolean first = true;
-		output.append("[");
-
-		for (Entry<Object, Object> entry : map.entrySet()) {
-			if (first)
-				first = false;
-			else
-				output.append(", ");
-
-			printValue(output, entry.getKey(), stop, previous, hierachyIndex - 1, printer);
-			output.append(": ");
-			printValue(output, entry.getValue(),  stop, previous, hierachyIndex - 1, printer);
-		}
-
-		output.append("]");
-	}
-	
-	private static void printArray(StringBuilder output, Object array, Class<?> current, Class<?> stop,
-								   Set<Object> previous, int hierachyIndex, ObjectPrinter printer) throws IllegalAccessException {
-		
-		Class<?> component = current.getComponentType();
-		boolean first = true;
-		
-		if (!component.isArray())
-			output.append(component.getName());
-		output.append("[");
-		
-		for (int i = 0; i < Array.getLength(array); i++) {
-			if (first)
-				first = false;
-			else
-				output.append(", ");
-			
-			// Handle exceptions
-			try {
-				printValue(output, Array.get(array, i), component, stop, previous, hierachyIndex - 1, printer);
-			} catch (ArrayIndexOutOfBoundsException e) {
-				e.printStackTrace();
-				break;
-			} catch (IllegalArgumentException e) {
-				e.printStackTrace();
-				break;
-			}
-		}
-		
-		output.append("]");
-	}
-	
-	// Internal recursion method
-	private static void printObject(StringBuilder output, Object object, Class<?> current, Class<?> stop,
-									Set<Object> previous, int hierachyIndex, boolean first,
-									ObjectPrinter printer) throws IllegalAccessException {
-		
-		// See if we're supposed to skip this class
-		if (current == null || current == Object.class || (stop != null && current.equals(stop))) {
-			return;
-		}
-
-		// Don't iterate twice
-		previous.add(object);
-		
-		// Hard coded limit
-		if (hierachyIndex < 0) {
-			output.append("...");
-			return;
-		}
-		
-		for (Field field : current.getDeclaredFields()) {
-			int mod = field.getModifiers();
-			
-			// Skip a good number of the fields
-			if (!Modifier.isTransient(mod) && !Modifier.isStatic(mod)) {
-				Class<?> type = field.getType();
-				Object value = FieldUtils.readField(field, object, true);
-				
-				if (first) {
-					first = false;
-				} else {
-					output.append(", ");
-				}
-				
-				output.append(field.getName());
-				output.append(" = ");
-				printValue(output, value, type, stop, previous, hierachyIndex - 1, printer);
-			}
-		}
-		
-		// Recurse
-		printObject(output, object, current.getSuperclass(), stop, previous, hierachyIndex, first, printer);
-	}
-
-	private static void printValue(StringBuilder output, Object value, Class<?> stop,
-								   Set<Object> previous, int hierachyIndex, ObjectPrinter printer) throws IllegalAccessException {
-		// Handle the NULL case
-		printValue(output, value, value != null ? value.getClass() : null, stop, previous, hierachyIndex, printer);
-	}
-	
-	@SuppressWarnings({"rawtypes", "unchecked"})
-	private static void printValue(StringBuilder output, Object value, Class<?> type,
-								   Class<?> stop, Set<Object> previous, int hierachyIndex,
-								   ObjectPrinter printer) throws IllegalAccessException {
-	
-		// Just print primitive types
-		if (printer.print(output, value)) {
-			return;
-		} else if (value == null) {
-			output.append("NULL");
-		} else if (type.isPrimitive() || Primitives.isWrapperType(type)) {
-			output.append(value);
-		} else if (type == String.class || hierachyIndex <= 0) {
-			output.append("\"" + value + "\"");
-		} else if (type.isArray()) {
-			printArray(output, value, type, stop, previous, hierachyIndex, printer);
-		} else if (Iterable.class.isAssignableFrom(type)) {
-			printIterables(output, (Iterable) value, stop, previous, hierachyIndex, printer);
-		} else if (Map.class.isAssignableFrom(type)) {
-			printMap(output, (Map<Object, Object>) value, type, stop, previous, hierachyIndex, printer);
-		} else if (ClassLoader.class.isAssignableFrom(type) || previous.contains(value)) {
-			// Don't print previous objects
-			output.append("\"" + value + "\"");
-		} else {
-			output.append("{ ");
-			printObject(output, value, value.getClass(), stop, previous, hierachyIndex, true, printer);
-			output.append(" }");
-		}
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/reflect/StructureModifier.java

@@ -1,685 +0,0 @@
-/*
- *  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.reflect;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.logging.Level;
-
-import com.comphenix.protocol.ProtocolLibrary;
-import com.comphenix.protocol.ProtocolLogger;
-import com.comphenix.protocol.error.PluginContext;
-import com.comphenix.protocol.reflect.compiler.BackgroundCompiler;
-import com.comphenix.protocol.reflect.instances.BannedGenerator;
-import com.comphenix.protocol.reflect.instances.DefaultInstances;
-import com.comphenix.protocol.reflect.instances.InstanceProvider;
-import com.comphenix.protocol.utility.MinecraftReflection;
-import com.google.common.base.Function;
-import com.google.common.base.Objects;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Lists;
-
-/**
- * Provides list-oriented access to the fields of a Minecraft packet.
- * <p>
- * Implemented by using reflection. Use a CompiledStructureModifier, if speed is essential.
- * 
- * @author Kristian
- * @param <TField> Type of the fields to retrieve.
- */
-@SuppressWarnings("rawtypes")
-public class StructureModifier<TField> {
-	
-	// Object and its type
-	protected Class targetType;
-	protected Object target;
-	
-	// Converter. May be NULL.
-	protected EquivalentConverter<TField> converter;
-	
-	// The fields to read in order
-	protected Class fieldType;
-	protected List<Field> data = new ArrayList<Field>();
-	
-	// Improved default values
-	protected Map<Field, Integer> defaultFields;
-	
-	// Cache of previous types
-	protected Map<Class, StructureModifier> subtypeCache;
-	
-	// Whether or subclasses should handle conversion
-	protected boolean customConvertHandling;
-	
-	// Whether or not to automatically compile the structure modifier
-	protected boolean useStructureCompiler;
-	
-	// Instance generator we wil use
-	private static DefaultInstances DEFAULT_GENERATOR = getDefaultGenerator();
-
-	private static DefaultInstances getDefaultGenerator() {
-		List<InstanceProvider> providers = Lists.newArrayList();
-		
-		// Prevent certain classes from being generated
-		providers.add(new BannedGenerator(MinecraftReflection.getItemStackClass(), MinecraftReflection.getBlockClass()));
-		providers.addAll(DefaultInstances.DEFAULT.getRegistered());
-		return DefaultInstances.fromCollection(providers);
-	}
-			
-	/**
-	 * Creates a structure modifier.
-	 * @param targetType - the structure to modify.
-	 */
-	public StructureModifier(Class targetType) {
-		this(targetType, null, true);
-	}
-	
-	/**
-	 * Creates a structure modifier.
-	 * @param targetType - the structure to modify.
-	 * @param useStructureCompiler - whether or not to use a structure compiler.
-	 */
-	public StructureModifier(Class targetType, boolean useStructureCompiler) {
-		this(targetType, null, true, useStructureCompiler);
-	}
-	
-	/**
-	 * Creates a structure modifier.
-	 * @param targetType - the structure to modify.
-	 * @param superclassExclude - a superclass to exclude.
-	 * @param requireDefault - whether or not we will be using writeDefaults().
-	 */
-	public StructureModifier(Class targetType, Class superclassExclude, boolean requireDefault) {
-		this(targetType, superclassExclude, requireDefault, true);
-	}
-	
-	/**
-	 * Creates a structure modifier.
-	 * @param targetType - the structure to modify.
-	 * @param superclassExclude - a superclass to exclude.
-	 * @param requireDefault - whether or not we will be using writeDefaults().
-	 * @param useStructureCompiler - whether or not to automatically compile this structure modifier.
-	 */
-	public StructureModifier(Class targetType, Class superclassExclude, boolean requireDefault, boolean useStructureCompiler) {
-		List<Field> fields = getFields(targetType, superclassExclude);
-		Map<Field, Integer> defaults = requireDefault ? generateDefaultFields(fields) : new HashMap<Field, Integer>();
-		
-		initialize(targetType, Object.class, fields, defaults, null,
-				   new ConcurrentHashMap<Class, StructureModifier>(), useStructureCompiler);
-	}
-	
-	/**
-	 * Consumers of this method should call "initialize".
-	 */
-	protected StructureModifier() {
-		
-	}
-	
-	/**
-	 * Initialize using the same field types.
-	 * @param other - information to set.
-	 */
-	protected void initialize(StructureModifier<TField> other) {
-		initialize(other.targetType, other.fieldType, other.data,
-				   other.defaultFields, other.converter, other.subtypeCache,
-				   other.useStructureCompiler);
-	}
-	
-	/**
-	 * Initialize every field of this class.
-	 * @param targetType - type of the object we're reading and writing from.
-	 * @param fieldType - the common type of the fields we're modifying.
-	 * @param data - list of fields to modify.
-	 * @param defaultFields - list of fields that will be automatically initialized.
-	 * @param converter - converts between the common field type and the actual type the consumer expects.
-	 * @param subTypeCache - a structure modifier cache.
-	 */
-	protected void initialize(Class targetType, Class fieldType,
-			  List<Field> data, Map<Field, Integer> defaultFields,
-			  EquivalentConverter<TField> converter, Map<Class, StructureModifier> subTypeCache) {
-		initialize(targetType, fieldType, data, defaultFields, converter, subTypeCache, true);
-	}
-	
-	/**
-	 * Initialize every field of this class.
-	 * @param targetType - type of the object we're reading and writing from.
-	 * @param fieldType - the common type of the fields we're modifying.
-	 * @param data - list of fields to modify.
-	 * @param defaultFields - list of fields that will be automatically initialized.
-	 * @param converter - converts between the common field type and the actual type the consumer expects.
-	 * @param subTypeCache - a structure modifier cache.
-	 * @param useStructureCompiler - whether or not to automatically compile this structure modifier.
-	 */
-	protected void initialize(Class targetType, Class fieldType,
-			  List<Field> data, Map<Field, Integer> defaultFields,
-			  EquivalentConverter<TField> converter, Map<Class, StructureModifier> subTypeCache,
-			  boolean useStructureCompiler) {
-		
-		this.targetType = targetType;
-		this.fieldType = fieldType;
-		this.data = data;
-		this.defaultFields = defaultFields;
-		this.converter = converter;
-		this.subtypeCache = subTypeCache;
-		this.useStructureCompiler = useStructureCompiler;
-	}
-
-	/**
-	 * Reads the value of a field given its index.
-	 * <p>
-	 * Note: This method is prone to exceptions (there are currently 5 total throw statements). It is recommended that you
-	 * use {@link #readSafely(int)}, which returns {@code null} if the field doesn't exist, instead of throwing an exception.
-	 * 
-	 * @param fieldIndex - index of the field.
-	 * @return Value of the field.
-	 * @throws FieldAccessException if the field doesn't exist, or it cannot be accessed under the current security contraints.
-	 */
-	public TField read(int fieldIndex) throws FieldAccessException {
-		try {
-			return readInternal(fieldIndex);
-		} catch (FieldAccessException ex) {
-			String plugin = PluginContext.getPluginCaller(ex);
-			if (ProtocolLibrary.INCOMPATIBLE.contains(plugin)) {
-				ProtocolLogger.log(Level.WARNING, "Encountered an exception caused by incompatible plugin {0}.", plugin);
-				ProtocolLogger.log(Level.WARNING, "It is advised that you remove it.");
-			}
-
-			throw ex;
-		}
-	}
-
-	@SuppressWarnings("unchecked")
-	private TField readInternal(int fieldIndex) throws FieldAccessException {
-		if (target == null)
-			throw new IllegalStateException("Cannot read from a null target!");
-
-		if (fieldIndex < 0)
-			throw new FieldAccessException(String.format("Field index (%s) cannot be negative.", fieldIndex));
-
-		if (data.size() == 0)
-			throw new FieldAccessException(String.format("No field with type %s exists in class %s.", fieldType.getName(),
-					target.getClass().getSimpleName()));
-
-		if (fieldIndex >= data.size())
-			throw new FieldAccessException(String.format("Field index out of bounds. (Index: %s, Size: %s)", fieldIndex, data.size()));
-
-		try {
-			Object result = FieldUtils.readField(data.get(fieldIndex), target, true);
-
-			// Use the converter, if we have it
-			if (needConversion()) {
-				return converter.getSpecific(result);
-			} else {
-				return (TField) result;
-			}
-		} catch (IllegalAccessException e) {
-			throw new FieldAccessException("Cannot read field due to a security limitation.", e);
-		}
-	}
-	
-	/**
-	 * Reads the value of a field only if it exists. If the field does not exist, {@code null} is returned.
-	 * <p>
-	 * As its name implies, this method is a much safer alternative to {@link #read(int)}.
-	 * In addition to throwing less exceptions and thereby causing less console spam, this
-	 * method makes providing backwards compatiblity signficiantly easier, as shown below:
-	 * 
-	 * <pre><code>
-	 * BlockPosition position = packet.getBlockPositionModifier().readSafely(0);
-	 * if (position != null) {
-	 *     // Handle 1.8+
-	 * } else {
-	 *     // Handle 1.7-
-	 * }
-	 * </code></pre>
-	 * 
-	 * @param fieldIndex - index of the field.
-	 * @return Value of the field, or NULL if it doesn't exist.
-	 * @throws FieldAccessException if the field cannot be accessed under the current security constraints.
-	 */
-	public TField readSafely(int fieldIndex) throws FieldAccessException {
-		if (fieldIndex >= 0 && fieldIndex < data.size()) {
-			return read(fieldIndex);
-		} else {
-			return null;
-		}
-	}
-	
-	/**
-	 * Determine whether or not a field is read-only (final).
-	 * @param fieldIndex - index of the field.
-	 * @return TRUE if the field by the given index is read-only, FALSE otherwise.
-	 */
-	public boolean isReadOnly(int fieldIndex) {
-		return Modifier.isFinal(getField(fieldIndex).getModifiers());
-	}
-	
-	/**
-	 * Determine if a given field is public or not.
-	 * @param fieldIndex - field index.
-	 * @return TRUE if the field is public, FALSE otherwise.
-	 */
-	public boolean isPublic(int fieldIndex) {
-		return Modifier.isPublic(getField(fieldIndex).getModifiers());
-	}
-	
-	/**
-	 * Set whether or not a field should be treated as read only.
-	 * <p>
-	 * Note that changing the read-only state to TRUE will only work if the current
-	 * field was recently read-only or the current structure modifier hasn't been compiled yet.
-	 * 
-	 * @param fieldIndex - index of the field.
-	 * @param value - TRUE if this field should be read only, FALSE otherwise.
-	 * @throws FieldAccessException If we cannot modify the read-only status.
-	 */
-	public void setReadOnly(int fieldIndex, boolean value) throws FieldAccessException {
-		if (fieldIndex < 0 || fieldIndex >= data.size())
-			throw new IllegalArgumentException("Index parameter is not within [0 - " + data.size() + ")");
-
-		try {
-			StructureModifier.setFinalState(data.get(fieldIndex), value);
-		} catch (IllegalAccessException e) {
-			throw new FieldAccessException("Cannot write read only status due to a security limitation.", e);
-		}
-	}
-	
-	/**
-	 * Alter the final status of a field.
-	 * @param field - the field to change.
-	 * @param isReadOnly - TRUE if the field should be read only, FALSE otherwise.
-	 * @throws IllegalAccessException If an error occured.
-	 */
-	protected static void setFinalState(Field field, boolean isReadOnly) throws IllegalAccessException {
-	    if (isReadOnly)
-	    	FieldUtils.writeField((Object) field, "modifiers", field.getModifiers() | Modifier.FINAL, true);
-	    else
-	    	FieldUtils.writeField((Object) field, "modifiers", field.getModifiers() & ~Modifier.FINAL, true);
-	}
-	
-	/**
-	 * Writes the value of a field given its index.
-	 * @param fieldIndex - index of the field.
-	 * @param value - new value of the field.
-	 * @return This structure modifier - for chaining.
-	 * @throws FieldAccessException The field doesn't exist, or it cannot be accessed under the current security contraints.
-	 */
-	public StructureModifier<TField> write(int fieldIndex, TField value) throws FieldAccessException {
-		try {
-			return writeInternal(fieldIndex, value);
-		} catch (FieldAccessException ex) {
-			String plugin = PluginContext.getPluginCaller(ex);
-			if (ProtocolLibrary.INCOMPATIBLE.contains(plugin)) {
-				ProtocolLogger.log(Level.WARNING, "Encountered an exception caused by incompatible plugin {0}.", plugin);
-				ProtocolLogger.log(Level.WARNING, "It is advised that you remove it.");
-			}
-
-			throw ex;
-		}
-	}
-
-	private StructureModifier<TField> writeInternal(int fieldIndex, TField value) throws FieldAccessException {
-		if (target == null)
-			throw new IllegalStateException("Cannot read from a null target!");
-
-		if (fieldIndex < 0)
-			throw new FieldAccessException(String.format("Field index (%s) cannot be negative.", fieldIndex));
-
-		if (data.size() == 0)
-			throw new FieldAccessException(String.format("No field with type %s exists in class %s.", fieldType.getName(),
-					target.getClass().getSimpleName()));
-
-		if (fieldIndex >= data.size())
-			throw new FieldAccessException(String.format("Field index out of bounds. (Index: %s, Size: %s)", fieldIndex, data.size()));
-
-		// Use the converter, if it exists
-		Object obj = needConversion() ? converter.getGeneric(getFieldType(fieldIndex), value) : value;
-
-		try {
-			FieldUtils.writeField(data.get(fieldIndex), target, obj, true);
-		} catch (IllegalAccessException e) {
-			throw new FieldAccessException("Cannot read field due to a security limitation.", e);
-		}
-
-		// Make this method chainable
-		return this;
-	}
-	
-	/**
-	 * Retrieve the type of a specified field.
-	 * @param index - the index.
-	 * @return The type of the given field.
-	 */
-	protected Class<?> getFieldType(int index) {
-		return data.get(index).getType();
-	}
-	
-	/**
-	 * Whether or not we should use the converter instance.
-	 * @return TRUE if we should, FALSE otherwise.
-	 */
-	private final boolean needConversion() {
-		return converter != null && !customConvertHandling;
-	}
-	
-	/**
-	 * Writes the value of a given field IF and ONLY if it exists.
-	 * @param fieldIndex - index of the potential field.
-	 * @param value - new value of the field.
-	 * @return This structure modifer - for chaining.
-	 * @throws FieldAccessException The field cannot be accessed under the current security contraints.
-	 */
-	public StructureModifier<TField> writeSafely(int fieldIndex, TField value) throws FieldAccessException {
-		if (fieldIndex >= 0 && fieldIndex < data.size()) {
-			write(fieldIndex, value);
-		}
-		return this;
-	}
-	
-	/**
-	 * Correctly modifies the value of a field.
-	 * @param fieldIndex - index of the field to modify.
-	 * @param select - the function that modifies the field value.
-	 * @return This structure modifier - for chaining.
-	 * @throws FieldAccessException The field cannot be accessed under the current security contraints.
-	 */
-	public StructureModifier<TField> modify(int fieldIndex, Function<TField, TField> select) throws FieldAccessException {
-		TField value = read(fieldIndex);
-		return write(fieldIndex, select.apply(value));
-	}
-	
-	/**
-	 * Retrieves a structure modifier that only reads and writes fields of a given type.
-	 * @param <T> Type
-	 * @param fieldType - the type, or supertype, of every field to modify.
-	 * @return A structure modifier for fields of this type.
-	 */
-	public <T> StructureModifier<T> withType(Class fieldType) {
-		return withType(fieldType, null);
-	}
-	
-	/**
-	 * Sets all non-primitive fields to a more fitting default value. See {@link DefaultInstances#getDefault(Class)}.
-	 * @return The current structure modifier - for chaining.
-	 * @throws FieldAccessException If we're unable to write to the fields due to a security limitation.
-	 */
-	public StructureModifier<TField> writeDefaults() throws FieldAccessException {
-		DefaultInstances generator = DefaultInstances.DEFAULT;
-
-		// Write a default instance to every field
-		for (Field field : defaultFields.keySet()) {
-			try {
-				// Special case for Spigot's custom chat components
-				// They must be null or messages will be blank
-				if (field.getType().getCanonicalName().equals("net.md_5.bungee.api.chat.BaseComponent[]")) {
-					FieldUtils.writeField(field, target, null, true);
-					continue;
-				}
-
-				FieldUtils.writeField(field, target, generator.getDefault(field.getType()), true);
-			} catch (IllegalAccessException e) {
-				throw new FieldAccessException("Cannot write to field due to a security limitation.", e);
-			}
-		}
-
-		return this;
-	}
-	
-	/**
-	 * Retrieves a structure modifier that only reads and writes fields of a given type.
-	 * @param <T> Type
-	 * @param fieldType - the type, or supertype, of every field to modify.
-	 * @param converter - converts objects into the given type.
-	 * @return A structure modifier for fields of this type.
-	 */
-	@SuppressWarnings("unchecked")
-	public <T> StructureModifier<T> withType(Class fieldType, EquivalentConverter<T> converter) {
-		StructureModifier<T> result = subtypeCache.get(fieldType);
-		
-		// Do we need to update the cache?
-		if (result == null) {
-			List<Field> filtered = new ArrayList<Field>();
-			Map<Field, Integer> defaults = new HashMap<Field, Integer>();
-			int index = 0;
-			
-			for (Field field : data) {
-				if (fieldType != null && fieldType.isAssignableFrom(field.getType())) {
-					filtered.add(field);
-					
-					// Don't use the original index
-					if (defaultFields.containsKey(field))
-						defaults.put(field, index);
-				}
-				
-				// Keep track of the field index
-				index++;
-			}
-			
-			// Cache structure modifiers
-			result = withFieldType(fieldType, filtered, defaults);
-			
-			if (fieldType != null) {
-				subtypeCache.put(fieldType, result);
-				
-				// Automatically compile the structure modifier
-				if (useStructureCompiler && BackgroundCompiler.getInstance() != null)
-					BackgroundCompiler.getInstance().scheduleCompilation(subtypeCache, fieldType);
-			}
-		}
-		
-		// Add the target too
-		result = result.withTarget(target);
-		
-		// And the converter, if it's needed
-		if (!Objects.equal(result.converter, converter)) {
-			result = result.withConverter(converter);
-		}
-		return result;
-	}
-	
-	/**
-	 * Retrieves the common type of each field.
-	 * @return Common type of each field.
-	 */
-	public Class getFieldType() {
-		return fieldType;
-	}
-	
-	/**
-	 * Retrieves the type of the object we're modifying.
-	 * @return Type of the object.
-	 */
-	public Class getTargetType() {
-		return targetType;
-	}
-	
-	/**
-	 * Retrieves the object we're currently modifying.
-	 * @return Object we're modifying.
-	 */
-	public Object getTarget() {
-		return target;
-	}
-	
-	/**
-	 * Retrieve the number of readable types.
-	 * @return Readable types.
-	 */
-	public int size() {
-		return data.size();
-	}
-	
-	/**
-	 * Create a new structure modifier for the new field type.
-	 * @param <T> Type
-	 * @param fieldType - common type of each field.
-	 * @param filtered - list of fields after filtering the original modifier.
-	 * @param defaults - list of default values after filtering the original.
-	 * @return A new structure modifier.
-	 */
-	protected <T> StructureModifier<T> withFieldType(
-			Class fieldType, List<Field> filtered, Map<Field, Integer> defaults) {
-		return withFieldType(fieldType, filtered, defaults, null);
-	}
-	
-	/**
-	 * Create a new structure modifier for the new field type.
-	 * @param <T> Type
-	 * @param fieldType - common type of each field.
-	 * @param filtered - list of fields after filtering the original modifier.
-	 * @param defaults - list of default values after filtering the original.
-	 * @param converter - the new converter, or NULL.
-	 * @return A new structure modifier.
-	 */
-	protected <T> StructureModifier<T> withFieldType(
-			Class fieldType, List<Field> filtered,
-			Map<Field, Integer> defaults, EquivalentConverter<T> converter) {
-		
-		StructureModifier<T> result = new StructureModifier<T>();
-		result.initialize(targetType, fieldType, filtered, defaults,
-						  converter, new ConcurrentHashMap<Class, StructureModifier>(),
-						  useStructureCompiler);
-		return result;
-	}
-	
-	/**
-	 * Retrieves a structure modifier of the same type for a different object target.
-	 * @param target - different target of the same type.
-	 * @return Structure modifier with the new target.
-	 */
-	public StructureModifier<TField> withTarget(Object target) {
-		StructureModifier<TField> copy = new StructureModifier<TField>();
-		
-		// Create a new instance
-		copy.initialize(this);
-		copy.target = target;
-		return copy;
-	}
-	
-	/**
-	 * Retrieves a structure modifier with the same type and target, but using a new object converter.
-	 * @param converter - the object converter to use.
-	 * @return Structure modifier with the new converter.
-	 */
-	@SuppressWarnings("unchecked")
-	private <T> StructureModifier<T> withConverter(EquivalentConverter<T> converter) {
-		StructureModifier copy = withTarget(target);
-		
-		copy.setConverter(converter);
-		return copy;
-	}
-	
-	/**
-	 * Set the current object converter. Should only be called during construction.
-	 * @param converter - current object converter.
-	 */
-	protected void setConverter(EquivalentConverter<TField> converter) {
-		this.converter = converter;
-	}
-	
-	/**
-	 * Retrieves a list of the fields matching the constraints of this structure modifier.
-	 * @return List of fields.
-	 */
-	public List<Field> getFields() {
-		return ImmutableList.copyOf(data);
-	}
-
-	/**
-	 * Retrieve a field by index.
-	 * @param fieldIndex - index of the field to retrieve.
-	 * @return The field represented with the given index.
-	 * @throws IllegalArgumentException If no field with the given index can be found.
-	 */
-	public Field getField(int fieldIndex) {
-		if (fieldIndex < 0 || fieldIndex >= data.size())
-			throw new IllegalArgumentException("Index parameter is not within [0 - " + data.size() + ")");
-		
-		return data.get(fieldIndex);
-	}
-	
-	/**
-	 * Retrieve every value stored in the fields of the current type.
-	 * @return Every field value.
-	 * @throws FieldAccessException Unable to access one or all of the fields
-	 */
-	public List<TField> getValues() throws FieldAccessException {
-		List<TField> values = new ArrayList<TField>();
-		
-		for (int i = 0; i < size(); i++) {
-			values.add(read(i));
-		}
-		
-		return values;
-	}
-	
-	// Used to generate plausible default values
-	private static Map<Field, Integer> generateDefaultFields(List<Field> fields) {
-		
-		Map<Field, Integer> requireDefaults = new HashMap<Field, Integer>();
-		DefaultInstances generator = DEFAULT_GENERATOR;
-		int index = 0;
-		
-		for (Field field : fields) {
-			Class<?> type = field.getType();
-			int modifier = field.getModifiers();
-			
-			// First, ignore primitive fields and final fields
-			if (!type.isPrimitive() && !Modifier.isFinal(modifier)) {
-				// Next, see if we actually can generate a default value
-				if (generator.getDefault(type) != null) {
-					// If so, require it
-					requireDefaults.put(field, index);
-				}
-			}
-			
-			// Increment field index
-			index++;
-		}
-		
-		return requireDefaults;
-	}
-	
-	// Used to filter out irrelevant fields
-	private static List<Field> getFields(Class type, Class superclassExclude) {
-		List<Field> result = new ArrayList<Field>();
-		
-		// Retrieve every private and public field
-		for (Field field : FuzzyReflection.fromClass(type, true).getDeclaredFields(superclassExclude)) {
-			int mod = field.getModifiers();
-			
-			// Ignore static and "abstract packet" fields
-			if (!Modifier.isStatic(mod) &&
-					(superclassExclude == null || !field.getDeclaringClass().equals(superclassExclude)
-				)) {
-				
-				result.add(field);
-			}
-		}
-		return result;
-	}
-
-	@Override
-	public String toString() {
-		return "StructureModifier[fieldType=" + fieldType + ", data=" + data + "]";
-	}
-}

modules/API/src/main/java/com/comphenix/protocol/reflect/VolatileField.java

@@ -1,243 +0,0 @@
-/*
- *  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.reflect;
-
-import java.lang.reflect.Field;
-
-import com.comphenix.protocol.ProtocolLogger;
-import com.comphenix.protocol.reflect.accessors.Accessors;
-import com.comphenix.protocol.reflect.accessors.FieldAccessor;
-import com.google.common.base.Objects;
-
-/**
- * Represents a field that will revert to its original state when this class is garbaged collected.
- * 
- * @author Kristian
- */
-public class VolatileField {
-	private FieldAccessor accessor;
-	private Object container;
-	
-	// The current and previous values
-	private Object previous;
-	private Object current;
-	
-	// Whether or not we must reset or load
-	private boolean previousLoaded;
-	private boolean currentSet;
-
-	// Whether or not to break access restrictions
-	private boolean forceAccess;
-	
-	/**
-	 * Initializes a volatile field with an associated object.
-	 * @param field - the field.
-	 * @param container - the object this field belongs to.
-	 */
-	public VolatileField(Field field, Object container) {
-		this.accessor = Accessors.getFieldAccessor(field);
-		this.container = container;
-	}
-	
-	/**
-	 * Initializes a volatile field with an associated object.
-	 * @param field - the field.
-	 * @param container - the object this field belongs to.
-	 * @param forceAccess - whether or not to override any scope restrictions.
-	 */
-	public VolatileField(Field field, Object container, boolean forceAccess) {
-		this.accessor = Accessors.getFieldAccessor(field, true);
-		this.container = container;
-		this.forceAccess = forceAccess;
-	}
-	
-	/**
-	 * Initializes a volatile field with the given accessor and associated object.
-	 * @param accessor - the field accessor.
-	 * @param container - the object this field belongs to.
-	 */
-	public VolatileField(FieldAccessor accessor, Object container) {
-		this.accessor = accessor;
-		this.container = container;
-	}
-	
-	/**
-	 * Retrieves the current field.
-	 * @return The stored field.
-	 */
-	public Field getField() {
-		return accessor.getField();
-	}
-	
-	/**
-	 * Retrieves the object the field is stored.
-	 * @return The reference object.
-	 */
-	public Object getContainer() {
-		return container;
-	}
-	
-	/**
-	 * Retrieves whether or not not to override any scope restrictions.
-	 * @return TRUE if we override scope, FALSE otherwise.
-	 */
-	public boolean isForceAccess() {
-		return forceAccess;
-	}
-
-	/**
-	 * Sets whether or not not to override any scope restrictions.
-	 * @param forceAccess - TRUE if we override scope, FALSE otherwise.
-	 */
-	public void setForceAccess(boolean forceAccess) {
-		this.forceAccess = forceAccess;
-	}
-
-	/**
-	 * Retrieves the current field value.
-	 * @return The current field value.
-	 */
-	public Object getValue() {
-		// Retrieve the correct value
-		if (!currentSet) {
-			ensureLoaded();
-			return previous;
-		} else {
-			return current;
-		}
-	}
-	
-	/**
-	 * Retrieves the field value before the previous setValue(), unless saveValue() has been called.
-	 * @return Previous value.
-	 */
-	public Object getOldValue() {
-		ensureLoaded();
-		return previous;
-	}
-	
-	/**
-	 * Sets the current value. This will be reverted unless saveValue() is called.
-	 * @param newValue - new field value.
-	 */
-	public void setValue(Object newValue) {
-		// Remember to safe the previous value
-		ensureLoaded();
-		
-		writeFieldValue(newValue);
-		current = newValue;
-		currentSet = true;
-	}
-	
-	/**
-	 * Reapply the current changed value.
-	 * <p>
-	 * Also refresh the previously set value.
-	 */
-	public void refreshValue() {
-		Object fieldValue = readFieldValue();
-		
-		if (currentSet) {
-			// If they differ, we need to set them again
-			if (!Objects.equal(current, fieldValue)) {
-				previous = readFieldValue();
-				previousLoaded = true;
-				writeFieldValue(current);
-			}
-		} else if (previousLoaded) {
-			// Update that too
-			previous = fieldValue;
-		}
-	}
-	
-	/**
-	 * Ensure that the current value is still set after this class has been garbaged collected.
-	 */
-	public void saveValue() {
-		previous = current;
-		currentSet = false;
-	}
-	
-	/**
-	 * Revert to the previously set value.
-	 */
-	public void revertValue() {
-		// Reset value if it hasn't been changed by anyone else
-		if (currentSet) {
-			if (getValue() == current) {
-				setValue(previous);
-				currentSet = false;
-			} else {
-				// This can be a bad sign
-				ProtocolLogger.log("Unable to switch {0} to {1}. Expected {2}, but got {3}.", getField().toGenericString(), previous, current, getValue());
-			}
-		}
-	}
-	
-	/**
-	 * Retrieve a synchronized version of the current field.
-	 * @return A synchronized volatile field.
-	 */
-	public VolatileField toSynchronized() {
-		return new VolatileField(Accessors.getSynchronized(accessor), container);
-	}
-	
-	/**
-	 * Determine whether or not we'll need to revert the value.
-	 * @return True if it is set, false if not.
-	 */
-	public boolean isCurrentSet() {
-		return currentSet;
-	}
-	
-	private void ensureLoaded() {
-		// Load the value if we haven't already
-		if (!previousLoaded) {
-			previous = readFieldValue();
-			previousLoaded = true;
-		}
-	}
-	
-	/**
-	 * Read the content of the underlying field.
-	 * @return The field value.
-	 */
-	private Object readFieldValue() {
-		return accessor.get(container);
-	}
-	
-	/**
-	 * Write the given value to the underlying field.
-	 * @param newValue - the new value.
-	 */
-	private void writeFieldValue(Object newValue) {
-		accessor.set(container, newValue);
-	}
-		
-	@Override
-	protected void finalize() throws Throwable {
-		revertValue();
-	}
-
-	@Override
-	public String toString() {
-		return "VolatileField [accessor=" + accessor + ", container=" + container + ", previous="
-				+ previous + ", current=" + current + ", previousLoaded=" + previousLoaded
-				+ ", currentSet=" + currentSet + ", forceAccess=" + forceAccess + "]";
-	}
-}