Crest Schedule

https://github.com/xlevitate/crest-schedule
Admin
Crest Schedule is a powerful and intuitive Java library for Bukkit/Paper Minecraft plugins, offering...
Tokens:2,361
Snippets:12
Trust Score:7.4
Update:1 year ago
Show doc for...
Tokens:
Raw
### Gradle Installation (Groovy DSL)

Source: https://github.com/xlevitate/crest-schedule/blob/main/README.md

Adds the JitPack repository and the crest-schedule dependency to your project using Gradle's Groovy DSL.

```gradle
repositories {
    mavenCentral()
    maven { url 'https://jitpack.io' }
}

dependencies {
    implementation 'com.github.xLevitate:crest-schedule:v1.0.0'
}
```

--------------------------------

### Gradle Installation (Kotlin DSL)

Source: https://github.com/xlevitate/crest-schedule/blob/main/README.md

Adds the JitPack repository and the crest-schedule dependency to your project using Gradle's Kotlin DSL.

```gradle
repositories {
    mavenCentral()
    maven("https://jitpack.io")
}

dependencies {
    implementation("com.github.xLevitate:crest-schedule:v1.0.0")
}
```

--------------------------------

### Error Handling and Timeouts (Java)

Source: https://github.com/xlevitate/crest-schedule/blob/main/README.md

Illustrates how to implement robust task execution by handling potential errors and setting timeouts for asynchronous operations. Includes examples for individual and combined error/timeout management.

```java
import com.moocrest.scheduler.Scheduler;

// Error handling
Scheduler.async()
    .onError(throwable -> {
        getLogger().severe("Task failed: " + throwable.getMessage());
        throwable.printStackTrace();
    })
    .run(() -> {
        // Risky operation
        riskyOperation();
    });

// Timeout handling
Scheduler.async()
    .timeout(100) // 5 seconds
    .onTimeout(() -> {
        getLogger().warning("Operation timed out!");
    })
    .run(() -> {
        // Long running operation
        longRunningOperation();
    });

// Combined error and timeout handling
Scheduler.sync()
    .delay(20)
    .timeout(200)
    .onError(throwable -> handleError(throwable))
    .onTimeout(() -> handleTimeout())
    .run(() -> {
        performOperation();
    });
```

--------------------------------

### Create, Manage, and Check Task Groups in Java

Source: https://github.com/xlevitate/crest-schedule/blob/main/README.md

Demonstrates how to create task groups, add synchronous and asynchronous tasks with delays and repetitions, cancel all tasks within a group, and retrieve active task counts and group names. Requires the com.moocrest.scheduler library.

```Java
import com.moocrest.scheduler.group.TaskGroup;

// Create a task group
TaskGroup group = Scheduler.group("my-tasks");
// or
TaskGroup group = Scheduler.createTaskGroup(); // Creates "default" group

// Add tasks to the group
group.sync()
    .delay(20)
    .repeat(40)
    .run(() -> {
        getLogger().info("Group task 1");
    });

group.async()
    .run(() -> {
        getLogger().info("Group task 2");
    });

// Cancel all tasks in the group
group.cancelAll();

// Check group status
int activeTasks = group.getActiveTaskCount();
boolean hasActiveTasks = group.hasActiveTasks();

// Get group name
String groupName = group.getName();
```

--------------------------------

### Synchronous Task Scheduling (Java)

Source: https://github.com/xlevitate/crest-schedule/blob/main/README.md

Demonstrates various ways to schedule tasks on the main server thread. Includes immediate execution, delayed execution, repeating tasks, conditional execution, and task chaining.

```java
import com.moocrest.scheduler.Scheduler;
import com.moocrest.scheduler.ScheduledTask;

// Simple sync task
Scheduler.sync().run(() -> {
    // Runs on main thread immediately
    getLogger().info("Hello from sync task!");
});

// Delayed sync task
Scheduler.sync()
    .delay(20) // Wait 1 second (20 ticks)
    .run(() -> {
        getLogger().info("Delayed sync task!");
    });

// Repeating sync task
Scheduler.sync()
    .delay(20)    // Initial delay
    .repeat(40)   // Repeat every 2 seconds
    .times(5)     // Run 5 times total
    .run(() -> {
        getLogger().info("Repeating sync task!");
    });

// Conditional sync tasks
Scheduler.sync().runIf(() -> getServer().getOnlinePlayers().size() > 0, () -> {
    getLogger().info("Players are online!");
});

Scheduler.sync()
    .repeat(20)
    .runWhile(() -> getServer().getOnlinePlayers().size() > 0, () -> {
        getLogger().info("Still have players online!");
    });

// Task chaining
Scheduler.sync()
    .run(() -> getLogger().info("First task"))
    .thenRun(() -> getLogger().info("Second task"))
    .thenAsync(() -> {
        // Switch to async
        return "async result";
    });
```

--------------------------------

### Asynchronous Task Scheduling (Java)

Source: https://github.com/xlevitate/crest-schedule/blob/main/README.md

Shows how to schedule tasks to run off the main thread for I/O operations or long computations. Covers simple async tasks, tasks returning results, and chaining between async and sync contexts.

```java
import com.moocrest.scheduler.Scheduler;
import java.util.concurrent.CompletableFuture;

// Simple async task
Scheduler.async().run(() -> {
    // Runs on async thread
    // Safe for database operations, file I/O, etc.
    performDatabaseOperation();
});

// Async task with result
CompletableFuture<String> future = Scheduler.async().supply(() -> {
    return fetchDataFromAPI();
});

// Async to sync chaining
Scheduler.async()
    .storeResult(() -> {
        // Async operation
        return fetchPlayerData();
    })
    .thenSync(result -> {
        // Back to main thread with result
        updatePlayerDisplay(result);
    });

// Complex async chaining
Scheduler.async()
    .delay(10)
    .timeout(100) // Cancel if takes longer than 5 seconds
    .onTimeout(() -> getLogger().warning("Task timed out!"))
    .onError(throwable -> getLogger().severe("Task failed: " + throwable.getMessage()))
    .storeResult(() -> {
        return performLongRunningOperation();
    })
    .thenSync(result -> {
        // Process result on main thread
        handleResult(result);
    });
```

--------------------------------

### Initialize Scheduler (Java)

Source: https://github.com/xlevitate/crest-schedule/blob/main/README.md

Initializes the Crest Schedule library within your Bukkit/Paper plugin's onEnable method. This is a prerequisite for using any scheduling features.

```java
import com.moocrest.scheduler.Scheduler;

// Initialize the scheduler in your plugin's onEnable()
Scheduler.initialize(this);
```

--------------------------------

### Batch Processing with Error Handling in Java

Source: https://github.com/xlevitate/crest-schedule/blob/main/README.md

Demonstrates batch processing of a list of items (e.g., player UUIDs) with optional delays between items and robust error handling for individual operations. This ensures that failures in one item do not stop the entire batch.

```Java
// Batch processing with error handling
List<UUID> playerUUIDs = getPlayerUUIDs();

Scheduler.async()
    .onError(throwable -> {
        getLogger().severe("Batch processing failed: " + throwable.getMessage());
    })
    .forEach(playerUUIDs)
    .delay(5) // Small delay between each UUID
    .run(uuid -> {
        try {
            processPlayerData(uuid);
        } catch (Exception e) {
            getLogger().warning("Failed to process player " + uuid + ": " + e.getMessage());
        }
    });
```

--------------------------------

### Control and Cancel Individual Scheduled Tasks in Java

Source: https://github.com/xlevitate/crest-schedule/blob/main/README.md

Shows how to obtain a reference to a scheduled task for manual control, check its running status, cancel it, and manage multiple tasks stored in a list. This allows for fine-grained management of scheduled operations.

```Java
// Get task reference for manual control
ScheduledTask task = Scheduler.sync()
    .delay(100)
    .repeat(20)
    .run(() -> {
        getLogger().info("Repeating task");
    });

// Check task status
boolean isRunning = !task.isCancelled();

// Cancel specific task
task.cancel();

// Store multiple tasks
List<ScheduledTask> tasks = new ArrayList<>();
tasks.add(Scheduler.sync().delay(20).run(() -> task1()));
tasks.add(Scheduler.async().run(() -> task2()));

// Cancel all stored tasks
tasks.forEach(ScheduledTask::cancel);
```

--------------------------------

### Chained Async/Sync Operations for Data Workflow in Java

Source: https://github.com/xlevitate/crest-schedule/blob/main/README.md

Illustrates a complex workflow involving fetching data asynchronously, processing it on the main thread (e.g., Bukkit API), and then saving the processed data asynchronously. This pattern is useful for managing I/O-bound and CPU-bound operations efficiently.

```Java
// Complex workflow: async data fetch -> sync processing -> async save
Scheduler.async()
    .storeResult(() -> {
        // Fetch data from external API
        return apiClient.fetchUserData(userId);
    })
    .thenSync(userData -> {
        // Process on main thread (access Bukkit API)
        Player player = getServer().getPlayer(userData.getName());
        if (player != null) {
            player.sendMessage("Welcome back, " + userData.getDisplayName() + "!");
            return userData;
        }
        return null;
    })
    .thenAsync(processedData -> {
        if (processedData != null) {
            // Save to database
            database.saveUserData(processedData);
        }
    });
```

--------------------------------

### Conditional Repeating Task with Automatic Cleanup in Java

Source: https://github.com/xlevitate/crest-schedule/blob/main/README.md

Shows how to create a repeating task that runs until a specific condition is met, after which it automatically stops. This is useful for tasks that should run periodically but have a defined exit criterion.

```Java
// Conditional repeating task with automatic cleanup
Scheduler.sync()
    .repeat(20) // Every second
    .runUntil(
        () -> getServer().getOnlinePlayers().isEmpty(), // Stop condition
        () -> {
            // Task to run until condition is met
            broadcastMessage("Server has players online!");
        }
    );
```

--------------------------------

### ForEach Operations (Java)

Source: https://github.com/xlevitate/crest-schedule/blob/main/README.md

Enables processing collections of items sequentially, either synchronously or asynchronously. Allows specifying delays between processing each item in the collection.

```java
import com.moocrest.scheduler.Scheduler;
import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;

// Process list items with delay between each
List<Player> players = new ArrayList<>(getServer().getOnlinePlayers());

Scheduler.sync()
    .forEach(players)
    .delay(10) // 0.5 second delay between each player
    .run(player -> {
        player.sendMessage("Hello " + player.getName() + "!");
    });

// Async forEach for heavy operations
List<String> playerNames = Arrays.asList("player1", "player2", "player3");

Scheduler.async()
    .forEach(playerNames)
    .delay(20) // 1 second delay between each
    .run(playerName -> {
        // Heavy operation for each player
        processPlayerData(playerName);
    });
```
Tokens:
Raw