me.clip.placeholderapi.expansion.PlaceholderExpansion Java Examples

/**
 * Unregister all expansions provided by PlaceholderAPI
 */
public static void unregisterAllProvidedExpansions() {
  if (placeholders.isEmpty()) {
    return;
  }
  
  getPlaceholders().forEach((key, value) -> {
    if (value instanceof PlaceholderExpansion) {
      PlaceholderExpansion ex = (PlaceholderExpansion) value;
      
      if (!ex.persist()) {
        unregisterExpansion(ex);
      }
    }
  });
}
 

@Override
public void register() {
    Set<String> variables = Sets.newHashSet();

    Collection<PlaceholderHook> hooks = PlaceholderAPI.getPlaceholders().values();
    for (PlaceholderHook hook : hooks) {
        String variablePrefix = null;
        if (hook instanceof EZPlaceholderHook) {
            variablePrefix = ((EZPlaceholderHook) hook).getPlaceholderName();
        } else if (hook instanceof PlaceholderExpansion) {
            variablePrefix = ((PlaceholderExpansion) hook).getIdentifier();
        }

        if (variablePrefix != null) {
            variables.add(variablePrefix + "_*");
        }
    }

    for (String variable : variables) {
        register(variable).supply(player -> PlaceholderAPI.setPlaceholders(player, '%' + variable + '%'));
    }
}
 

@EventHandler(priority = EventPriority.HIGH)
public void onPluginUnload(PluginDisableEvent e) {
  String n = e.getPlugin().getName();

  if (n == null) {
    return;
  }

  if (n.equals(plugin.getName())) {
    return;
  }

  Map<String, PlaceholderHook> hooks = PlaceholderAPI.getPlaceholders();

  for (Entry<String, PlaceholderHook> hook : hooks.entrySet()) {
    PlaceholderHook i = hook.getValue();

    if (i instanceof PlaceholderExpansion) {
      PlaceholderExpansion ex = (PlaceholderExpansion) i;

      if (ex.getRequiredPlugin() == null) {
        continue;
      }

      if (ex.getRequiredPlugin().equalsIgnoreCase(n)) {
        if (PlaceholderAPI.unregisterExpansion(ex)) {
          plugin.getLogger().info("Unregistered placeholder expansion: " + ex.getIdentifier());
        }
      }
    }
  }
}
 

@EventHandler
public void onQuit(PlayerQuitEvent e) {
  Set<PlaceholderExpansion> expansions = PlaceholderAPI.getExpansions();

  if (expansions.isEmpty()) {
    return;
  }

  for (PlaceholderExpansion ex : expansions) {
    if (ex instanceof Cleanable) {
      ((Cleanable) ex).cleanup(e.getPlayer());
    }
  }
}
 

private void setupMetrics() {
  Metrics m = new Metrics(this);
  m.addCustomChart(new Metrics.SimplePie("using_expansion_cloud",
      () -> getExpansionCloud() != null ? "yes" : "no"));

  m.addCustomChart(
      new Metrics.SimplePie("using_spigot", () -> getServerVersion().isSpigot() ? "yes" : "no"));

  m.addCustomChart(new Metrics.AdvancedPie("expansions_used", () -> {
    Map<String, Integer> map = new HashMap<>();
    Map<String, PlaceholderHook> p = PlaceholderAPI.getPlaceholders();

    if (!p.isEmpty()) {

      for (PlaceholderHook hook : p.values()) {
        if (hook instanceof PlaceholderExpansion) {
          PlaceholderExpansion ex = (PlaceholderExpansion) hook;
          map.put(ex.getRequiredPlugin() == null ? ex.getIdentifier()
              : ex.getRequiredPlugin(), 1);
        }
      }
    }
    return map;

  }));

}
 

public static Set<PlaceholderExpansion> getExpansions() {
  Set<PlaceholderExpansion> set = getPlaceholders().values().stream()
          .filter(PlaceholderExpansion.class::isInstance).map(PlaceholderExpansion.class::cast)
          .collect(Collectors.toCollection(HashSet::new));
  
  return ImmutableSet.copyOf(set);
}
 

public static boolean registerExpansion(PlaceholderExpansion ex) {
  ExpansionRegisterEvent ev = new ExpansionRegisterEvent(ex);
  Bukkit.getPluginManager().callEvent(ev);
  if (ev.isCancelled()) {
    return false;
  }
  
  return registerPlaceholderHook(ex.getIdentifier(), ex);
}
 

public static boolean unregisterExpansion(PlaceholderExpansion ex) {
  if (unregisterPlaceholderHook(ex.getIdentifier())) {
    Bukkit.getPluginManager().callEvent(new ExpansionUnregisterEvent(ex));
    return true;
  }
  
  return false;
}
 

@Override
public void registerExpansion(Class pluginClass) {
    try {
        ((PlaceholderExpansion) pluginClass.newInstance()).register();
    } catch (Throwable t) {
        t.printStackTrace();
    }
}
 

public ExpansionRegisterEvent(PlaceholderExpansion expansion) {
  this.expansion = expansion;
}
 

public PlaceholderExpansion getExpansion() {
  return expansion;
}
 

public ExpansionUnregisterEvent(PlaceholderExpansion expansion) {
  this.expansion = expansion;
}
 

public PlaceholderExpansion getExpansion() {
  return expansion;
}
 

@Override
public boolean isPlaceholderExpansion(Class pluginClass) {
    return PlaceholderExpansion.class.isAssignableFrom(pluginClass);
}