Abstract Event Annotations

Event Annotations

Ever wanted to catch all bukkit events that extend a specific event?
Have you been dismayed to find that bukkit cries if you actually try to
do this with a normal EventHandler? Ever wanted to do all of that without adding
additional dependencies to your runtime?

Probably not. But if you have... introducing...

ExpandEventHandler

ExpandEventHandler

is a fancy dancy annotation you can throw on your should
be working with bukkit event handler instead of the standard `EventHandler` annotation.

Heres how it looks in the real world:

@ExpandEventHandler 
 void  onPlayerEvent  (  PlayerEvent event  )   {  
     //Amazingly sound logic and flawless code  
    ... 
     //and so on  
 }

Wow! Amazing. So cool!

But hey, some events are stupid right? Like

org.bukkit.event.player.PlayerInteractAtEntityEvent

Oh dear. We don't want that one. lets get rid of it:

@ExpandEventHandler  (  exclude  =   {  PlayerInteractAtEntityEvent.  class   }   )  
 void  onPlayerEvent  (  PlayerEvent event  )   {  
     //Amazingly sound logic and flawless code  
    ... 
     //and so on  
 }

Yay!

Some events are also trash even according to bukkit/spigot. Those darn deprecated events...
So lets go ahead and add them all to the exclude list one by one by one by...

Just kidding. Those already are exlcuded. Maybe we want them though:

@ExpandEventHandler  (  includeDeprecated  =   true   )  
 void  onPlayerEvent  (  PlayerEvent event  )   {  
     //Amazingly sound logic and flawless code  
    ... 
     //and so on  
 }

And thats all!

Actually Use the Damn Thing
Great. Now you know how to use it... but how do you like... actually use it???

Its pretty straightforward. Build the thing from source using these 600 dependencies:

...

Ok not really. Just download the provided jar or build the project using gradle and then compile
your plugin with the jar on the classpath.

Heres an example with gradle:

compileOnly fileTree(dir: 'path/to/directory/containing/jar/', include: '*.jar')

(Note compileOnly - this tool is only used for compiling your plugin, and for nothing else)

How it works
It just does... I think? I've tested it like twice.

But in all seriousness what we are actually doing is using an annotation processor that
processes the

ExpandEventHandler

mentioned before.

The processor takes the argument type from the annotated method, and uses ClassGraph to
find all of its concrete subclasses. (Thanks to Trigary for pointing me towards the post he wrote explaining
how to do the ClassGraph magic)

Finally, we use Javacs non public barely documented oh god this sucked "Read Only" Abstract Syntax Tree API
to modify (heh read only) the AST before javac turns it into bytecode, injecting handlers for each event type
that delegate to your original method.

And then boom! Your class compiles and has many many methods you didn't have to write.

Example Decompiled Bytecode Snippet

public   void  onPlayerEvent  (  PlayerEvent event  )   {  
     //astounding plugin code  
 }  

@EventHandler 
 public   void  onPlayerItemBreakEvent  (  PlayerItemBreakEvent event  )   {  
     this  .  onPlayerEvent   (  event  )   ;  
 }  

@EventHandler 
 public   void  onPlayerItemConsumeEvent  (  PlayerItemConsumeEvent event  )   {  
     this  .  onPlayerEvent   (  event  )   ;  
 }  

@EventHandler 
 public   void  onPlayerItemDamageEvent  (  PlayerItemDamageEvent event  )   {  
     this  .  onPlayerEvent   (  event  )   ;  
 }  

@EventHandler 
 public   void  onPlayerItemHeldEvent  (  PlayerItemHeldEvent event  )   {  
     this  .  onPlayerEvent   (  event  )   ;  
 }  

@EventHandler 
 public   void  onPlayerItemMendEvent  (  PlayerItemMendEvent event  )   {  
     this  .  onPlayerEvent   (  event  )   ;  
 }  

@EventHandler 
 public   void  onPlayerJoinEvent  (  PlayerJoinEvent event  )   {  
     this  .  onPlayerEvent   (  event  )   ;  
 }  

@EventHandler 
 public   void  onPlayerKickEvent  (  PlayerKickEvent event  )   {  
     this  .  onPlayerEvent   (  event  )   ;  
 }  

... 
 and  so on 
...