co.aikar.timings.Timing Java Examples

public boolean batchDataPacket(DataPacket packet) {
    if (!this.connected) {
        return false;
    }

    try (Timing timing = Timings.getSendDataPacketTiming(packet)) {
        DataPacketSendEvent event = new DataPacketSendEvent(this, packet);
        this.server.getPluginManager().callEvent(event);
        if (event.isCancelled()) {
            return false;
        }

        if (!this.batchedPackets.containsKey(packet.getChannel())) {
            this.batchedPackets.put(packet.getChannel(), new ArrayList<>());
        }

        this.batchedPackets.get(packet.getChannel()).add(packet.clone());
    }
    return true;
}
 

public int directDataPacket(DataPacket packet, boolean needACK) {
    if (!this.connected) {
        return -1;
    }

    try (Timing timing = Timings.getSendDataPacketTiming(packet)) {
        DataPacketSendEvent ev = new DataPacketSendEvent(this, packet);
        this.server.getPluginManager().callEvent(ev);
        if (ev.isCancelled()) {
            timing.stopTiming();
            return -1;
        }

        Integer identifier = this.interfaz.putPacket(this, packet, needACK, true);

        if (needACK && identifier != null) {
            this.needACK.put(identifier, Boolean.FALSE);
            timing.stopTiming();
            return identifier;
        }
    }
    return 0;
}
 

public int dataPacket(DataPacket packet, boolean needACK) {
    if (!this.connected) {
        return -1;
    }

    try (Timing timing = Timings.getSendDataPacketTiming(packet)) {
        DataPacketSendEvent ev = new DataPacketSendEvent(this, packet);
        this.server.getPluginManager().callEvent(ev);
        if (ev.isCancelled()) {
            timing.stopTiming();
            return -1;
        }

        Integer identifier = this.interfaz.putPacket(this, packet, needACK, false);

        if (needACK && identifier != null) {
            this.needACK.put(identifier, Boolean.FALSE);
            timing.stopTiming();
            return identifier;
        }
    }
    return 0;
}
 

public boolean batchDataPacket(DataPacket packet) {
    if (!this.connected) {
        return false;
    }

    try (Timing timing = Timings.getSendDataPacketTiming(packet)) {
        DataPacketSendEvent event = new DataPacketSendEvent(this, packet);
        this.server.getPluginManager().callEvent(event);
        if (event.isCancelled()) {
            timing.stopTiming();
            return false;
        }

        if (!this.batchedPackets.containsKey(packet.getChannel())) {
            this.batchedPackets.put(packet.getChannel(), new ArrayList<>());
        }

        this.batchedPackets.get(packet.getChannel()).add(packet.clone());
    }
    return true;
}
 

@Override
public void handleDataPacket(DataPacket packet) {
    if (!this.isSynapseLogin) {
        super.handleDataPacket(packet);
        return;
    }
    Timing dataPacketTiming = handlePlayerDataPacketTimings.getOrDefault(packet.pid(), TimingsManager.getTiming("SynapseEntry - HandlePlayerDataPacket - " + packet.getClass().getSimpleName()));
    dataPacketTiming.startTiming();

    super.handleDataPacket(packet);

    dataPacketTiming.stopTiming();
    if (!handlePlayerDataPacketTimings.containsKey(packet.pid()))
        handlePlayerDataPacketTimings.put(packet.pid(), dataPacketTiming);

}
 

public int directDataPacket(DataPacket packet, boolean needACK) {
    if (!this.connected) {
        return -1;
    }

    try (Timing timing = Timings.getSendDataPacketTiming(packet)) {
        DataPacketSendEvent ev = new DataPacketSendEvent(this, packet);
        this.server.getPluginManager().callEvent(ev);
        if (ev.isCancelled()) {
            return -1;
        }

        Integer identifier = this.interfaz.putPacket(this, packet, needACK, true);

        if (needACK && identifier != null) {
            this.needACK.put(identifier, Boolean.FALSE);
            return identifier;
        }
    }
    return 0;
}
 

public int dataPacket(DataPacket packet, boolean needACK) {
    if (!this.connected) {
        return -1;
    }

    try (Timing timing = Timings.getSendDataPacketTiming(packet)) {
        DataPacketSendEvent ev = new DataPacketSendEvent(this, packet);
        this.server.getPluginManager().callEvent(ev);
        if (ev.isCancelled()) {
            return -1;
        }

        if (log.isTraceEnabled() && !(packet instanceof BatchPacket)) {
            log.trace("Outbound {}: {}", this.getName(), packet);
        }

        Integer identifier = this.interfaz.putPacket(this, packet, needACK, false);

        if (needACK && identifier != null) {
            this.needACK.put(identifier, Boolean.FALSE);
            return identifier;
        }
    }
    return 0;
}
 

@Override
public Consumer<Inventory> getUpdaterFor(String name, Player player)
{
    return inventory ->
    {
        try (Timing ignored1 = VirtualChestTimings.updateAndRefreshMappings(name).startTiming())
        {
            int index = 0;
            for (Slot slot : inventory.<Slot>slots())
            {
                try (Timing ignored2 = VirtualChestTimings.updateAndRefreshMapping(name, index).startTiming())
                {
                    this.setItemInInventory(player, slot, index++, name);
                }
            }
        }
    };
}
 

public boolean execute(Player player, Tuple<String, CompiledScript> tuple)
{
    String scriptLiteral = tuple.getFirst();
    ScriptContext context = this.getContext(player);
    try (Timing ignored = VirtualChestTimings.executeRequirementScript().startTiming())
    {
        return Boolean.valueOf(String.valueOf(tuple.getSecond().eval(context)));
    }
    catch (ScriptException e)
    {
        this.logger.error("Error found when executing script for player " + player.getName(), e);
        this.logger.debug("Literal: {}", scriptLiteral);
        this.logger.debug("Result: {}", Boolean.FALSE);
        return false;
    }
    finally
    {
        this.removeContextAttributes(context);
    }
}
 

public void registerEvent(Class<? extends Event> event, Listener listener, EventPriority priority, EventExecutor executor, Plugin plugin, boolean ignoreCancelled) throws PluginException {
    if (!plugin.isEnabled()) {
        throw new PluginException("Plugin attempted to register " + event + " while not enabled");
    }

    try {
        Timing timing = Timings.getPluginEventTiming(event, listener, executor, plugin);
        this.getEventListeners(event).register(new RegisteredListener(listener, executor, priority, plugin, ignoreCancelled, timing));
    } catch (IllegalAccessException e) {
        Server.getInstance().getLogger().logException(e);
    }
}
 

public RegisteredListener(Listener listener, EventExecutor executor, EventPriority priority, Plugin plugin, boolean ignoreCancelled, Timing timing) {
    this.listener = listener;
    this.priority = priority;
    this.plugin = plugin;
    this.executor = executor;
    this.ignoreCancelled = ignoreCancelled;
    this.timing = timing;
}
 

public void registerEvent(Class<? extends Event> event, Listener listener, EventPriority priority, EventExecutor executor, Plugin plugin, boolean ignoreCancelled) throws PluginException {
    if (!plugin.isEnabled()) {
        throw new PluginException("Plugin attempted to register " + event + " while not enabled");
    }

    try {
        Timing timing = Timings.getPluginEventTiming(event, listener, executor, plugin);
        this.getEventListeners(event).register(new RegisteredListener(listener, executor, priority, plugin, ignoreCancelled, timing));
    } catch (IllegalAccessException e) {
        Server.getInstance().getLogger().logException(e);
    }
}
 

public RegisteredListener(Listener listener, EventExecutor executor, EventPriority priority, Plugin plugin, boolean ignoreCancelled, Timing timing) {
    this.listener = listener;
    this.priority = priority;
    this.plugin = plugin;
    this.executor = executor;
    this.ignoreCancelled = ignoreCancelled;
    this.timing = timing;
}
 

public boolean matchRequirements(Player player, int index, String name)
{
    try (Timing ignored = VirtualChestTimings.checkRequirements(name, index).startTiming())
    {
        return this.plugin.getScriptManager().execute(player, this.requirements);
    }
}
 

public void fillInventory(Player player, Inventory inventory, int index, String name)
{
    try (Timing ignored = VirtualChestTimings.setItemInInventory(name, index).startTiming())
    {
        inventory.set(this.serializer.apply(player, this.serializedStack));
    }
    catch (InvalidDataException e)
    {
        String posString = VirtualChestInventory.slotIndexToKey(index);
        throw new InvalidDataException("Find error when generating item at " + posString, e);
    }
}
 

public RegisteredListener(Listener listener, EventExecutor executor, EventPriority priority, Plugin plugin, boolean ignoreCancelled, Timing timing) {
    this.listener = listener;
    this.priority = priority;
    this.plugin = plugin;
    this.executor = executor;
    this.ignoreCancelled = ignoreCancelled;
    this.timing = timing;
}
 

public void registerEvent(Class<? extends Event> event, Listener listener, EventPriority priority, EventExecutor executor, Plugin plugin, boolean ignoreCancelled) throws PluginException {
    if (!plugin.isEnabled()) {
        throw new PluginException("Plugin attempted to register " + event + " while not enabled");
    }

    try {
        Timing timing = Timings.getPluginEventTiming(event, listener, executor, plugin);
        this.getEventListeners(event).register(new RegisteredListener(listener, executor, priority, plugin, ignoreCancelled, timing));
    } catch (IllegalAccessException e) {
        Server.getInstance().getLogger().logException(e);
    }
}
 

private ScriptContext getContext(Player player)
{
    try (Timing ignored = VirtualChestTimings.prepareRequirementBindings().startTiming())
    {
        SimpleScriptContext context = this.tempContext;
        VirtualChestPlaceholderManager placeholderManager = this.plugin.getPlaceholderManager();
        Function<String, Object> papi = s -> Text.of(placeholderManager.replacePlaceholder(player, s)).toPlain();

        context.setAttribute("papi", papi, ScriptContext.ENGINE_SCOPE);
        context.setAttribute("player", player, ScriptContext.ENGINE_SCOPE);
        context.setAttribute("tick", this.getTickFromOpeningInventory(player), ScriptContext.ENGINE_SCOPE);

        return context;
    }
}
 

public static Timing updateAndRefreshMappings(String name)
{
    return Timings.of(PLUGIN, "updateAndRefreshMappings - " + name);
}
 

public Timing teleportCooldown()
{
	return teleportCooldown;
}
 

public Timing teleportPlayer()
{
	return teleportPlayer;
}
 

public Timing afk()
{
	return afk;
}
 

public Timing loginMessage()
{
	return loginMessage;
}
 

public Timing saveInventory()
{
	return saveInventory;
}
 

public Timing getMail()
{
	return mail;
}
 

public Timing safeLogin()
{
	return safeLogin;
}
 

public Timing firstJoin()
{
	return firstJoin;
}
 

private Timing timing(String key)
{
	return co.aikar.timings.Timings.of(this.plugin, key);
}
 

public static Timing executeRequirementScript()
{
    return EXECUTE_REQUIREMENT_SCRIPT;
}
 

public static void stop(@Nullable Object timing) {
	if (timing == null) // Timings disabled...
		return;
	((Timing) timing).stopTimingIfSync();
}