Increment to 2.2.1-SNAPSHOT for development towards the next version
Ensure that ProtocolLib discoveres mod-specific packets.
Fixed a bug overwriting the NetLoginHandler class with NetServerHandler
Don't attempt to clean up static members during an update.
Fix an NPE reported in ticket-38.
Add some debug information to a OutOfMemory exception.
Add the ability to load from the default package as well.
Set a maximum perm gen space usage for our background compiler.
Retry again if the hack isn't ready.
Correctly print the content of map objects in packets.
Provide a remove method in NbtCompound. Discourage getValue().

Added a missing remove method in NbtCompound. In addition, the
getValue() method in NbtCompount has been depreciated. It is far better
to use the put and get methods in NbtCompound instead.
NbtCompound can now accepts arbitrary primitive, list or map objects.
Add the ability to read arbitrary objects.

Perhaps NbtBase shouldn't have implemented getValue() after all - it
would have been better to have a shared base interface with getName()
and getType(), and only let the primitive elements implement getValue().

Too late to change it now though.
Fixed a couple of bugs discovered by FindBugs.
Experimental: InputStream -> Socket lookup by intercepting accept().

Previously, we have used a BlockingHashMap to simply lock the packet
read thread until we have had a chance to intercept the
NetLoginHandler/PendingConnection and store InputStream ->
PlayerInjector -> TemporaryPlayer. 

Problem is, this could potentially cause problems if, for some reason, a
packet is intercepted after the player has logged out and the player
injector has been removed from the lookup map. In that case, the read
thread would wait until it reaches the default timeout of 2 seconds.
Locking threads is fairly inefficient in general, and waiting for the
server connection thread to update the NetLoginHandler list could take a
while.

Instead, ProtocolLib will now intercept any Socket accepted in the
server's main ServerSocket, and record any calls to getInputStream().
That way, we can get a InputStream -> Socket mapping before the server
thread ever creates the read and write threads in NetLoginHandler ->
NetworkManager.

Unfortunately, it's not trivial to swap out the ServerSocket in the
DedicatedServerConnectionThread - we actually have to trigger the
accept() thread and move through a cycle of the loop before our custom 
ServerSocket is used. To do this, we will actually connect to the server
and read its MOTD manually, hopefully getting to it before any other
players. 

This creates a slight overhead of a couple of threads per server start,
but it's probably much better than locking the read thread. More testing
is needed though before this can be confirmed.
Increment to 2.2.2-SNAPSHOT
We cannot support plugin reloaders (PlugMan, PluginManagers).

This is because multiple plugins depend on us, and are not properly 
notified after ProtocolLib has been reloaded.

The only possible solution is to reload every dependent plugin after 
ProtocolLib has been reloaded, but unfortunately, I ran into
LinkageErrors when I tried it. So it's probably not possible with the
current architecture to support reloaders.

Instead, we'll simply print a BIG BOLD warning telling any users of
these plugins that ProtocolLib cannot be reloaded except through the
built in "/reload" command.
Moved classes that inject into the server thread to a separate package
Essentially, it's a lookup for a player's input stream.

Or: InputStream -> PlayerInjector -> Player.
Switch to a better InputStream -> Socket lookup for normal JVM.