Solved Generics in a listener

I am writing a mingame that uses a special ability class that has events in it... I want to compensate for 3 events while only using 1 event, but i also partially do not want to have all 3 event methods in the ability class...

The current class looks like this...

Code:java

 
package org.goblom.treasurehunt.api;
 
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityShootBowEvent;
import org.bukkit.event.entity.ProjectileLaunchEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.ItemStack;
 
/**
*
* @author Goblom
*/
public abstract class Ability implements Listener {
 
    public abstract String getName();
 
    public abstract ItemStack getItem();
 
    public abstract String getDescription();
 
    @EventHandler
    public void onInteract(PlayerInteractEvent event) {}
 
    @EventHandler
    public void onShootBow(EntityShootBowEvent event) {}
 
    @EventHandler
    public void onProjectileLaunch(ProjectileLaunchEvent event) {}
}
 

but i want it to work like this... (using generics)

Code:java

/*
* Copyright 2014 Goblom.
*/
 
package org.goblom.treasurehunt.api;
 
import org.bukkit.event.Event;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.inventory.ItemStack;
 
/**
*
* @author Goblom
*/
public abstract class Ability<EVENT extends Event> implements Listener {
 
    public abstract String getName();
 
    public abstract ItemStack getItem();
 
    public abstract String getDescription();
 
    @EventHandler
    public abstract void onEvent(EVENT event);
}

 

As far as im aware bukkit event system does not support generics.
Though you might be able to manually add your own RegisteredListener object to the handler list for each event.
Then check instanceof when it gets called.

 

The EntityShootBowEvent and ProjectileLaunchEvent can both be put under an EntityEvent but the PlayerInteractEvent is a PlayerEvent which gets separated from other Entities. You could listen for a plain old Event but then everything would end up going through that and could potentially cause a lot of lag.

Something you could do is in one listener class you listen for all of the events you need and then whenever you find one you send it into a single method in your Ability class (I think this is what Tzeentchful may have been getting at). So for instance in some event checker class you're listening for you EntityShootBowEvent, ProjectileLaunchEvent, and PlayerInteractEvent. Whenever one of these gets called, you call your onEvent() method in your Ability class with the event.

 

read source code of cbukkit and implement your own event registrator with support of generics.

 

How exactly is that done, i know plugins like "Per World Plugins" does that but i have never understood how it was done.

 

Instead of messing with internals I would just make a custom event that encompasses all of the events.

First off, make your custom event:
Gist Link

Code:java

 
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import org.bukkit.event.entity.EntityShootBowEvent;
import org.bukkit.event.entity.ProjectileLaunchEvent;
import org.bukkit.event.player.PlayerInteractEvent;
 
public class PlayerAbilityEvent extends Event {
 
private static final HandlerList handler = new HandlerList();
 
@Override
public HandlerList getHandlers() {
return handler;
}
 
public static HandlerList getHandlerList () {
return handler;
}
 
private final Event event;
private final int type;
 
public PlayerAbilityEvent (Event event) {
if(event instanceof PlayerInteractEvent)
type = 1;
else if(event instanceof EntityShootBowEvent)
type = 2;
else if(event instanceof ProjectileLaunchEvent)
type = 3;
else type = 0;
if(type == 0)
throw new IllegalArgumentException("The tst event can only accept PlayerInteractEvent, EntityShootBowEvent, and ProjectileLaunchEvent events.");
this.event = event;
}
 
public boolean isInteractEvent () {
return type == 1;
}
 
public boolean isEntityShootBowEvent () {
return type == 2;
}
 
public boolean isProjectileLaunchEvent () {
return type == 3;
}
 
public int getType () {
return type;
}
 
public PlayerInteractEvent getPlayerInteractEvent () {
if(isInteractEvent())
return (PlayerInteractEvent) event;
else
return null;
}
 
public EntityShootBowEvent getEntityShootBowEvent () {
if(isEntityShootBowEvent())
return (EntityShootBowEvent) event;
else
return null;
}
 
public ProjectileLaunchEvent getProjectileLaunchEvent () {
if(isProjectileLaunchEvent())
return (ProjectileLaunchEvent) event;
else
return null;
}
}
 

Then make a one time listener for the new event
Gist Link

Code:java

 
import org.bukkit.Bukkit;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityShootBowEvent;
import org.bukkit.event.entity.ProjectileLaunchEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.plugin.java.JavaPlugin;
 
public class AbilityListener implements Listener {
 
public AbilityListener (JavaPlugin plug) {
plug.getServer().getPluginManager().registerEvents(this, plug);
}
 
@EventHandler
public void onInteract (PlayerInteractEvent e) {
PlayerAbilityEvent event = new PlayerAbilityEvent(e);
Bukkit.getServer().getPluginManager().callEvent(event);
}
 
@EventHandler
public void onShootBow (EntityShootBowEvent e) {
PlayerAbilityEvent event = new PlayerAbilityEvent(e);
Bukkit.getServer().getPluginManager().callEvent(event);
}
 
@EventHandler
public void onProjectileLaunch (ProjectileLaunchEvent e) {
PlayerAbilityEvent event = new PlayerAbilityEvent(e);
Bukkit.getServer().getPluginManager().callEvent(event);
}
}
 

Make sure to turn on your listener in the onEnable function of your JavaPlugin

Code:java

 
public void onEnable() {
new AbilityListener(this);
}
 

Now you can make your Ability class with the one custom event
Gist Link

Code:java

 
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityShootBowEvent;
import org.bukkit.event.entity.ProjectileLaunchEvent;
import org.bukkit.event.player.PlayerInteractEvent;
 
public class Ability implements Listener {
 
/*
*  .... snip
*/
 
@EventHandler
public void onAbility (PlayerAbilityEvent e) {
if(e.isInteractEvent()) {
PlayerInteractEvent event = e.getPlayerInteractEvent();
//Do stuff with event
}else if(e.isEntityShootBowEvent()) {
EntityShootBowEvent event = e.getEntityShootBowEvent();
//Do stuff with event
}else if(e.isProjectileLaunchEvent()) {
ProjectileLaunchEvent event = e.getProjectileLaunchEvent();
//Do stuff with event
}
}
}
 

 

Goblom
Read source of cbukkit and use magical combination of c&v

 

RawCode if you don't have anything useful to say, then leave
Goblom why not have one listener that will forward the event to the best ability handler? (Based on, for example, held item)

 

Looking at your code, I wonder if you wouldn't do better to separate the Ability class out from your event listener class entirely. I like the MVC approach: model/view/controller, where the model (the backend logic, in this case your Ability class) is cleanly separated from the view (the classes which display data, e.g. changing the world somehow, or sending messages to players), and the controller (your event listeners, command handlers, etc.).

Embedding your model inside your controller just leads to contortions which ultimately won't help with the maintainability of your code. In this case, it looks like your Ability is something that a player would have, so your event handlers would check the abilities for the player concerned, and dispatch the event to each ability (I'm assuming a Player can have more than one abilty here).

I do this with Sensible Toolbox a lot; see https://github.com/desht/sensibleto...ensibletoolbox/listeners/GeneralListener.java (which dispatches events) and the abstract https://github.com/desht/sensibleto.../desht/sensibletoolbox/items/BaseSTBItem.java class (which defines the abstract methods to receive those dispatched events). Then I extend BaseSTBItem and implement the methods to receive the events that the listener passes on.

 

maybe something like that?

Code:java

public abstract class Ability {
 
public AbilityType type; // you can use just "insteadof ProjectileAbility " when you need, but enum is better for me :P
 
public Ability(AbilityType type)
{
    this.type = type;
}
 
 
public abstract String getName();
 
public abstract ItemStack getItem();
 
public abstract String getDescription();
protected abstract void onEvent(Event event);
 
public static enum AbilityType
{
    PROJECTILE, BOW_SHOOT, INTERACT;
}
}

Code:java

public abstract class ProjectileAbility extends Ability implements Listener {
// add constructor
 
 
@EventHandler
public void onProjectileLaunch(ProjectileLaunchEvent event)
{
    onEvent(event);
}
}

Code:java

public abstract class ShootBowAbility extends Ability implements Listener {
// add constructor
 
 
@EventHandler
public void onShootBow(EntityShootBowEvent event)
{
    onEvent(event);
}
}

Code:java

public abstract class InteractAbility extends Ability implements Listener {
// add constructor
 
 
@EventHandler
public void onInteract(PlayerInteractEvent event)
{
    onEvent(event);
}
}

 

I have already figured this out and gone ahead in development. (I apologize for not saying so earilier)

I am using something along the lines of what desht said. Use a listener then dispatch events to the ability.

 

read about "Type Erasure" and try again fireblast709

 

Just no. If you want to fight (reas as: discuss) about it, you can pm me if you want. Unlike you I like to keep threads clean. O btw, what has 'Type Erasure' to do with my post in the first place. The solution I provide does not even use generics.

 

One idea that comes to mind is using a ListenerFacade:

Code:java

public abstract class MyEvents {
 
    protected final YourPlugin plugin;
 
    public MyEvents(YourPlugin plugin) {
        this.plugin = plugin;
    }
 
    public final String getName() {
        return this.getClass().getName();
    }
 
    public abstract void onMove(PlayerMoveEvent event);
    public abstract void onInteract(PlayerInteractEvent event);
    //etc...
 
}

Code:java

public class ListenerFacade extends MyEvents implements Listener {
 
    protected final YourPlugin plugin;
    private static Map<String, MyEvents> listeners = new HashMap<>();
 
    public ListenerFacade(YourPlugin plugin) {
        this.plugin = plugin;
 
        MyEvents[] facades = new MyEvents[] {
            new SomeListener(this.plugin),
        };
 
        for (MyEvents ev : facades) {
            ListenerFacade.listeners.put(ev.getName(), ev);
        } 
    }
 
    @EventHandler
    public void onMove(PlayerMoveEvent event) {
        for (MyEvents ev : ListenerFacade.listeners) {
            ev.onMove(event);
        }
    }
 
    //etc...
 
}

Code:java

public class SomeListener extends MyEvents {
 
    public SomeListener(YourPlugin plugin) {
        super(plugin);
    }
 
    @EventHandler
    public void onMove(PlayerMoveEvent event) {...}
 
}

Though I don't really prefer it.