Task.java

package com.osroyale.game.task;
 
import java.util.Optional;
import java.util.UUID;

 
public abstract class Task {

    private final boolean instant;

    private int delay;

    private boolean running;

    private int counter;

    private Optional<Object> key = Optional.empty();

    private StackTraceElement[] creationStackTrace;

    private Optional<Long> runStartTime = Optional.empty();

    private final UUID uuid;

    private final long taskCreationTime;

    public Task(boolean instant, int delay) {
        if (delay <= 0) {
            instant = true;
            delay = 1;
        }
        this.instant = instant;
        this.delay = delay;
        this.creationStackTrace = Thread.currentThread().getStackTrace();
        this.uuid = UUID.randomUUID();
        this.taskCreationTime = System.currentTimeMillis();
    }
 
    public String getTaskId() {
        return uuid.toString();
    }

    public Task(int delay) {
        this(false, delay);
    }
 
    public void setExecutionTime() {
        runStartTime = Optional.of(System.currentTimeMillis());
    }
 
    public long getTaskCreationTime() {
        return taskCreationTime;
    }
 
    public Optional<Long> getRunStartTime() {
        return runStartTime;
    }
 
    public Long getElapsedTimeFromRunStartTime() {
        if (runStartTime.isPresent()) {
            return System.currentTimeMillis() - runStartTime.get();
        }
        return null;
    }
 
    public String getCreationStackTraceStr() {
        StringBuilder sb = new StringBuilder();
        for (StackTraceElement ste : creationStackTrace) {
            sb.append(ste.toString()).append("\n");
        }
        return sb.toString();
    }
 
    final synchronized void process() {
        if (++counter >= delay && running) {
            baseExecute();
            counter = 0;
        }
    }
 
    /***
     * Executes the abstract execute method ensuring any methods are called before and after
     */
    protected void baseExecute() {
        setExecutionTime();
        execute();
    }

    protected abstract void execute();

    public boolean canRun() {
        return true;
    }

    public synchronized final void cancel() {
        if (running) {
            onCancel(false);
            running = false;
        }
    }

    public synchronized final void cancel(boolean logout) {
        if (running) {
            onCancel(logout);
            running = false;
        }
    }

    void onLoop() { }

    protected void onSchedule() {  }

    protected boolean canSchedule() {
        return true;
    }

    protected void onCancel(boolean logout) { }

    void onException(Exception e) {
 
    }

    public Task attach(Object newKey) {
        key = Optional.ofNullable(newKey);
        return this;
    }

    public boolean isInstant() {
        return instant;
    }

    public int getDelay() {
        return delay;
    }

    public void setDelay(int delay) {
        this.delay = delay;
    }

    public boolean isRunning() {
        return running;
    }

    public Optional<Object> getAttachment() {
        return key;
    }
 
    synchronized void setRunning(boolean running) {
        this.running = running;
    }
}