From b3764bd6c4c8df66fd9e0e3547de4bce5157702c Mon Sep 17 00:00:00 2001 From: Piotr Zych <77621271+P1otrulla@users.noreply.github.com> Date: Sun, 12 Oct 2025 12:20:20 +0200 Subject: [PATCH 01/15] GH-1142 Add message placeholders for `msg_toggle` and `socialspy_status` * Register new placeholders for `msg_toggle` and `socialspy_status` in `MsgPlaceholderSetup`. * Extend `MsgMessages` with a `Placeholders` interface and implement language-specific placeholder formats in `ENMsgMessages` and `PLMsgMessages`. --- .../core/feature/msg/MsgPlaceholderSetup.java | 44 +++++++++++++++++++ .../feature/msg/messages/ENMsgMessages.java | 17 +++++++ .../feature/msg/messages/MsgMessages.java | 10 +++++ .../feature/msg/messages/PLMsgMessages.java | 16 +++++++ 4 files changed, 87 insertions(+) create mode 100644 eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java new file mode 100644 index 000000000..9fa64aa4c --- /dev/null +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java @@ -0,0 +1,44 @@ +package com.eternalcode.core.feature.msg; + +import com.eternalcode.core.feature.msg.toggle.MsgState; +import com.eternalcode.core.feature.msg.toggle.MsgToggleService; +import com.eternalcode.core.injector.annotations.Inject; +import com.eternalcode.core.injector.annotations.component.Controller; +import com.eternalcode.core.placeholder.PlaceholderRegistry; +import com.eternalcode.core.placeholder.PlaceholderReplacer; +import com.eternalcode.core.publish.Subscribe; +import com.eternalcode.core.publish.event.EternalInitializeEvent; +import java.util.UUID; + +@Controller +class MsgPlaceholderSetup { + + private final MsgService msgService; + private final MsgToggleService msgToggleService; + + @Inject + MsgPlaceholderSetup(MsgService msgService, MsgToggleService msgToggleService) { + this.msgService = msgService; + this.msgToggleService = msgToggleService; + } + + @Subscribe(EternalInitializeEvent.class) + void setUpPlaceholders(PlaceholderRegistry placeholderRegistry) { + placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( + "socialspy_status", + player -> { + UUID uuid = player.getUniqueId(); + return String.valueOf(this.msgService.isSpy(uuid)); + } + )); + + placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( + "msg_toggle", + player -> { + UUID uuid = player.getUniqueId(); + MsgState state = this.msgToggleService.getState(uuid).join(); + return state.name().toLowerCase(); + } + )); + } +} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/ENMsgMessages.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/ENMsgMessages.java index 2f353548f..f6fcb919f 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/ENMsgMessages.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/ENMsgMessages.java @@ -36,4 +36,21 @@ public class ENMsgMessages extends OkaeriConfig implements MsgMessages { public Notice socialSpyEnable = Notice.chat("► SocialSpy has been {STATE}!"); public Notice socialSpyDisable = Notice.chat("► SocialSpy has been {STATE}!"); + @Comment("# Formatowanie placeholderów") + public ENPlaceholders placeholders = new ENPlaceholders(); + + @Getter + @Accessors(fluent = true) + public static class ENPlaceholders implements MsgMessages.Placeholders { + + private String msgEnabled = "Enabled"; + private String msgDisabled = "Disabled"; + private String socialSpyEnabled = "Enabled"; + private String socialSpyDisabled = "Disabled"; + } + + public ENPlaceholders placeholders() { + return this.placeholders; + } + } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/MsgMessages.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/MsgMessages.java index 070f0b391..9a3d30d99 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/MsgMessages.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/MsgMessages.java @@ -17,4 +17,14 @@ public interface MsgMessages { Notice otherMessagesDisabled(); Notice otherMessagesEnabled(); + Placeholders placeholders(); + + interface Placeholders { + String msgEnabled(); + String msgDisabled(); + + String socialSpyEnabled(); + String socialSpyDisabled(); + } + } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/PLMsgMessages.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/PLMsgMessages.java index ece54845e..4fc650d99 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/PLMsgMessages.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/PLMsgMessages.java @@ -37,4 +37,20 @@ public class PLMsgMessages extends OkaeriConfig implements MsgMessages { public Notice otherMessagesDisabled = Notice.chat("► Wiadomości prywatne zostały wyłączone dla gracza {PLAYER}!"); public Notice otherMessagesEnabled = Notice.chat("► Wiadomości prywatne zostały włączone dla gracza {PLAYER}!"); + @Comment("# Formatowanie placeholderów") + public PLPlaceholders placeholders = new PLPlaceholders(); + + @Getter + @Accessors(fluent = true) + public static class PLPlaceholders implements MsgMessages.Placeholders { + + private String msgEnabled = "Włączone"; + private String msgDisabled = "Wyłączone"; + private String socialSpyEnabled = "Włączony"; + private String socialSpyDisabled = "Wyłączony"; + } + + public PLPlaceholders placeholders() { + return this.placeholders; + } } From af593f148e4bb0801c76d8cefd542c7fa4785636 Mon Sep 17 00:00:00 2001 From: Piotr Zych <77621271+P1otrulla@users.noreply.github.com> Date: Sun, 12 Oct 2025 12:28:46 +0200 Subject: [PATCH 02/15] GH-1143 Enhance `MsgPlaceholderSetup` with caching and new placeholders * Add caching logic for `msg_toggle` state in `MsgPlaceholderSetup`. * Introduce new formatted placeholders for `msg_toggle` and `socialspy_status`. * Extend `MsgMessages.Placeholders` to support a loading state with translations. --- .../core/feature/msg/MsgPlaceholderSetup.java | 76 ++++++++++++++++++- .../feature/msg/messages/ENMsgMessages.java | 1 + .../feature/msg/messages/MsgMessages.java | 2 + .../feature/msg/messages/PLMsgMessages.java | 1 + 4 files changed, 78 insertions(+), 2 deletions(-) diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java index 9fa64aa4c..3574d5f38 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java @@ -8,22 +8,35 @@ import com.eternalcode.core.placeholder.PlaceholderReplacer; import com.eternalcode.core.publish.Subscribe; import com.eternalcode.core.publish.event.EternalInitializeEvent; +import com.eternalcode.core.translation.Translation; +import com.eternalcode.core.translation.TranslationManager; +import java.time.Duration; +import java.time.Instant; import java.util.UUID; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ConcurrentHashMap; @Controller class MsgPlaceholderSetup { + private static final Duration CACHE_DURATION = Duration.ofMillis(200); + private final MsgService msgService; private final MsgToggleService msgToggleService; + private final TranslationManager translationManager; + private final ConcurrentHashMap stateCache = new ConcurrentHashMap<>(); @Inject - MsgPlaceholderSetup(MsgService msgService, MsgToggleService msgToggleService) { + MsgPlaceholderSetup(MsgService msgService, MsgToggleService msgToggleService, TranslationManager translationManager) { this.msgService = msgService; this.msgToggleService = msgToggleService; + this.translationManager = translationManager; } @Subscribe(EternalInitializeEvent.class) void setUpPlaceholders(PlaceholderRegistry placeholderRegistry) { + Translation translation = this.translationManager.getMessages(); + placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( "socialspy_status", player -> { @@ -32,13 +45,72 @@ void setUpPlaceholders(PlaceholderRegistry placeholderRegistry) { } )); + placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( + "socialspy_status_formatted", + player -> { + UUID uuid = player.getUniqueId(); + return this.msgService.isSpy(uuid) + ? translation.msg().placeholders().socialSpyEnabled() + : translation.msg().placeholders().socialSpyDisabled(); + } + )); + placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( "msg_toggle", player -> { UUID uuid = player.getUniqueId(); - MsgState state = this.msgToggleService.getState(uuid).join(); + MsgState state = this.getCachedOrLoadState(uuid); + + if (state == null) { + return translation.msg().placeholders().loading(); + } + return state.name().toLowerCase(); } )); + + placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( + "msg_toggle_formatted", + player -> { + UUID uuid = player.getUniqueId(); + MsgState state = this.getCachedOrLoadState(uuid); + + if (state == null) { + return translation.msg().placeholders().loading(); + } + + return state == MsgState.ENABLED + ? translation.msg().placeholders().msgEnabled() + : translation.msg().placeholders().msgDisabled(); + } + )); + } + + private MsgState getCachedOrLoadState(UUID uuid) { + CachedState cached = this.stateCache.get(uuid); + + if (cached != null && !cached.isExpired()) { + return cached.state(); + } + + CompletableFuture future = this.msgToggleService.getState(uuid); + + if (future.isDone() && !future.isCompletedExceptionally()) { + MsgState state = future.join(); + this.stateCache.put(uuid, new CachedState(state, Instant.now())); + return state; + } + + future.thenAccept(state -> + this.stateCache.put(uuid, new CachedState(state, Instant.now())) + ); + + return null; + } + + private record CachedState(MsgState state, Instant timestamp) { + boolean isExpired() { + return Duration.between(this.timestamp, Instant.now()).compareTo(CACHE_DURATION) > 0; + } } } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/ENMsgMessages.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/ENMsgMessages.java index f6fcb919f..f88543128 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/ENMsgMessages.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/ENMsgMessages.java @@ -42,6 +42,7 @@ public class ENMsgMessages extends OkaeriConfig implements MsgMessages { @Getter @Accessors(fluent = true) public static class ENPlaceholders implements MsgMessages.Placeholders { + private String loading = "Loading..."; private String msgEnabled = "Enabled"; private String msgDisabled = "Disabled"; diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/MsgMessages.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/MsgMessages.java index 9a3d30d99..9f5831a70 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/MsgMessages.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/MsgMessages.java @@ -20,6 +20,8 @@ public interface MsgMessages { Placeholders placeholders(); interface Placeholders { + String loading(); + String msgEnabled(); String msgDisabled(); diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/PLMsgMessages.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/PLMsgMessages.java index 4fc650d99..d2c5d9500 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/PLMsgMessages.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/PLMsgMessages.java @@ -43,6 +43,7 @@ public class PLMsgMessages extends OkaeriConfig implements MsgMessages { @Getter @Accessors(fluent = true) public static class PLPlaceholders implements MsgMessages.Placeholders { + private String loading = "Ładowanie..."; private String msgEnabled = "Włączone"; private String msgDisabled = "Wyłączone"; From 1f98392020814621dae10357f8ab860211355a62 Mon Sep 17 00:00:00 2001 From: Piotr Zych <77621271+P1otrulla@users.noreply.github.com> Date: Sun, 12 Oct 2025 12:43:37 +0200 Subject: [PATCH 03/15] GH-1144 Update `MsgPlaceholderSetup` caching and integrate `PlaceholderAPI` * Adjust cache duration in `MsgPlaceholderSetup` from 200ms to 5s. * Rename `msg_toggle` placeholders to `msg_status` for consistency. * Extend `ENPlaceholders` and `PLPlaceholders` with `OkaeriConfig`. * Add `PlaceholderAPI` dependency in `runServer` task configuration. --- .../eternalcode/core/feature/msg/MsgPlaceholderSetup.java | 6 +++--- .../core/feature/msg/messages/ENMsgMessages.java | 2 +- .../core/feature/msg/messages/PLMsgMessages.java | 2 +- eternalcore-plugin/build.gradle.kts | 6 +++++- 4 files changed, 10 insertions(+), 6 deletions(-) diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java index 3574d5f38..37839fe26 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java @@ -19,7 +19,7 @@ @Controller class MsgPlaceholderSetup { - private static final Duration CACHE_DURATION = Duration.ofMillis(200); + private static final Duration CACHE_DURATION = Duration.ofSeconds(5); private final MsgService msgService; private final MsgToggleService msgToggleService; @@ -56,7 +56,7 @@ void setUpPlaceholders(PlaceholderRegistry placeholderRegistry) { )); placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( - "msg_toggle", + "msg_status", player -> { UUID uuid = player.getUniqueId(); MsgState state = this.getCachedOrLoadState(uuid); @@ -70,7 +70,7 @@ void setUpPlaceholders(PlaceholderRegistry placeholderRegistry) { )); placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( - "msg_toggle_formatted", + "msg_status_formatted", player -> { UUID uuid = player.getUniqueId(); MsgState state = this.getCachedOrLoadState(uuid); diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/ENMsgMessages.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/ENMsgMessages.java index f88543128..143dd1e47 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/ENMsgMessages.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/ENMsgMessages.java @@ -41,7 +41,7 @@ public class ENMsgMessages extends OkaeriConfig implements MsgMessages { @Getter @Accessors(fluent = true) - public static class ENPlaceholders implements MsgMessages.Placeholders { + public static class ENPlaceholders extends OkaeriConfig implements MsgMessages.Placeholders { private String loading = "Loading..."; private String msgEnabled = "Enabled"; diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/PLMsgMessages.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/PLMsgMessages.java index d2c5d9500..581083182 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/PLMsgMessages.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/messages/PLMsgMessages.java @@ -42,7 +42,7 @@ public class PLMsgMessages extends OkaeriConfig implements MsgMessages { @Getter @Accessors(fluent = true) - public static class PLPlaceholders implements MsgMessages.Placeholders { + public static class PLPlaceholders extends OkaeriConfig implements MsgMessages.Placeholders { private String loading = "Ładowanie..."; private String msgEnabled = "Włączone"; diff --git a/eternalcore-plugin/build.gradle.kts b/eternalcore-plugin/build.gradle.kts index 0bf93dae7..bc0e2fe24 100644 --- a/eternalcore-plugin/build.gradle.kts +++ b/eternalcore-plugin/build.gradle.kts @@ -37,6 +37,10 @@ dependencies { tasks { runServer { minecraftVersion("1.21.8") - downloadPlugins.modrinth("luckperms", "v${Versions.LUCKPERMS}-bukkit") + + downloadPlugins { + modrinth("luckperms", "v${Versions.LUCKPERMS}-bukkit") + modrinth("placeholderapi", Versions.PLACEHOLDER_API) + } } } From cf7151ecb02695f522d102b00f719fdd4de3ab58 Mon Sep 17 00:00:00 2001 From: Piotr Zych <77621271+P1otrulla@users.noreply.github.com> Date: Sun, 12 Oct 2025 12:54:40 +0200 Subject: [PATCH 04/15] Refactor `MsgPlaceholderSetup` with new caching system * Replace existing cache in `MsgPlaceholderSetup` with `AsyncPlaceholderCached`. * Introduce `AsyncPlaceholderCacheRegistry` for managing placeholder caches. * Add `AsyncPlaceholderCacheController` to handle cache invalidation on player quit. * Simplify placeholder logic and remove redundant caching methods. --- .../core/feature/msg/MsgPlaceholderSetup.java | 49 +++-------------- .../AsyncPlaceholderCacheController.java | 24 +++++++++ .../cache/AsyncPlaceholderCacheRegistry.java | 53 +++++++++++++++++++ .../cache/AsyncPlaceholderCached.java | 51 ++++++++++++++++++ 4 files changed, 136 insertions(+), 41 deletions(-) create mode 100644 eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheController.java create mode 100644 eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheRegistry.java create mode 100644 eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCached.java diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java index 37839fe26..10f7a29c2 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java @@ -4,33 +4,27 @@ import com.eternalcode.core.feature.msg.toggle.MsgToggleService; import com.eternalcode.core.injector.annotations.Inject; import com.eternalcode.core.injector.annotations.component.Controller; +import com.eternalcode.core.placeholder.cache.AsyncPlaceholderCached; import com.eternalcode.core.placeholder.PlaceholderRegistry; import com.eternalcode.core.placeholder.PlaceholderReplacer; import com.eternalcode.core.publish.Subscribe; import com.eternalcode.core.publish.event.EternalInitializeEvent; import com.eternalcode.core.translation.Translation; import com.eternalcode.core.translation.TranslationManager; -import java.time.Duration; -import java.time.Instant; import java.util.UUID; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.ConcurrentHashMap; @Controller class MsgPlaceholderSetup { - private static final Duration CACHE_DURATION = Duration.ofSeconds(5); - private final MsgService msgService; - private final MsgToggleService msgToggleService; private final TranslationManager translationManager; - private final ConcurrentHashMap stateCache = new ConcurrentHashMap<>(); + private final AsyncPlaceholderCached stateCache; @Inject MsgPlaceholderSetup(MsgService msgService, MsgToggleService msgToggleService, TranslationManager translationManager) { this.msgService = msgService; - this.msgToggleService = msgToggleService; this.translationManager = translationManager; + this.stateCache = new AsyncPlaceholderCached<>(msgToggleService::getState); } @Subscribe(EternalInitializeEvent.class) @@ -39,10 +33,7 @@ void setUpPlaceholders(PlaceholderRegistry placeholderRegistry) { placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( "socialspy_status", - player -> { - UUID uuid = player.getUniqueId(); - return String.valueOf(this.msgService.isSpy(uuid)); - } + player -> String.valueOf(this.msgService.isSpy(player.getUniqueId())) )); placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( @@ -59,7 +50,7 @@ void setUpPlaceholders(PlaceholderRegistry placeholderRegistry) { "msg_status", player -> { UUID uuid = player.getUniqueId(); - MsgState state = this.getCachedOrLoadState(uuid); + MsgState state = this.stateCache.getCached(uuid); if (state == null) { return translation.msg().placeholders().loading(); @@ -73,7 +64,7 @@ void setUpPlaceholders(PlaceholderRegistry placeholderRegistry) { "msg_status_formatted", player -> { UUID uuid = player.getUniqueId(); - MsgState state = this.getCachedOrLoadState(uuid); + MsgState state = this.stateCache.getCached(uuid); if (state == null) { return translation.msg().placeholders().loading(); @@ -86,31 +77,7 @@ void setUpPlaceholders(PlaceholderRegistry placeholderRegistry) { )); } - private MsgState getCachedOrLoadState(UUID uuid) { - CachedState cached = this.stateCache.get(uuid); - - if (cached != null && !cached.isExpired()) { - return cached.state(); - } - - CompletableFuture future = this.msgToggleService.getState(uuid); - - if (future.isDone() && !future.isCompletedExceptionally()) { - MsgState state = future.join(); - this.stateCache.put(uuid, new CachedState(state, Instant.now())); - return state; - } - - future.thenAccept(state -> - this.stateCache.put(uuid, new CachedState(state, Instant.now())) - ); - - return null; - } - - private record CachedState(MsgState state, Instant timestamp) { - boolean isExpired() { - return Duration.between(this.timestamp, Instant.now()).compareTo(CACHE_DURATION) > 0; - } + public AsyncPlaceholderCached getStateCache() { + return this.stateCache; } } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheController.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheController.java new file mode 100644 index 000000000..bb0c8c6ac --- /dev/null +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheController.java @@ -0,0 +1,24 @@ +package com.eternalcode.core.placeholder.cache; + +import com.eternalcode.core.injector.annotations.Inject; +import com.eternalcode.core.injector.annotations.component.Controller; +import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerQuitEvent; + +@Controller +class AsyncPlaceholderCacheController implements Listener { + + private final AsyncPlaceholderCacheRegistry cacheRegistry; + + @Inject + AsyncPlaceholderCacheController(AsyncPlaceholderCacheRegistry cacheRegistry) { + this.cacheRegistry = cacheRegistry; + } + + @EventHandler(priority = EventPriority.MONITOR) + void onPlayerQuit(PlayerQuitEvent event) { + this.cacheRegistry.invalidatePlayer(event.getPlayer().getUniqueId()); + } +} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheRegistry.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheRegistry.java new file mode 100644 index 000000000..7b20a99b4 --- /dev/null +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheRegistry.java @@ -0,0 +1,53 @@ +package com.eternalcode.core.placeholder.cache; + +import com.eternalcode.core.injector.annotations.Inject; +import com.eternalcode.core.injector.annotations.component.Service; +import java.time.Duration; +import java.util.Map; +import java.util.Optional; +import java.util.UUID; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.Function; + +@Service +public class AsyncPlaceholderCacheRegistry { + + private static final Duration DEFAULT_EXPIRE_DURATION = Duration.ofMinutes(30); + + private final Map> caches = new ConcurrentHashMap<>(); + + @Inject + public AsyncPlaceholderCacheRegistry() { + } + + public AsyncPlaceholderCached register(String key, Function> loader) { + return this.register(key, loader, DEFAULT_EXPIRE_DURATION); + } + + public AsyncPlaceholderCached register(String key, Function> loader, Duration expireAfterWrite) { + AsyncPlaceholderCached cache = new AsyncPlaceholderCached<>(loader, expireAfterWrite); + this.caches.put(key, cache); + return cache; + } + + @SuppressWarnings("unchecked") + public Optional> get(String key) { + return Optional.ofNullable((AsyncPlaceholderCached) this.caches.get(key)); + } + + public void invalidatePlayer(UUID uuid) { + this.caches.values().forEach(cache -> cache.invalidate(uuid)); + } + + public void invalidateAll() { + this.caches.values().forEach(AsyncPlaceholderCached::clear); + } + + public void unregister(String key) { + AsyncPlaceholderCached cache = this.caches.remove(key); + if (cache != null) { + cache.clear(); + } + } +} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCached.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCached.java new file mode 100644 index 000000000..b0d05b58d --- /dev/null +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCached.java @@ -0,0 +1,51 @@ +package com.eternalcode.core.placeholder.cache; + +import com.google.common.cache.Cache; +import com.google.common.cache.CacheBuilder; +import java.time.Duration; +import java.util.UUID; +import java.util.concurrent.CompletableFuture; +import java.util.function.Function; + +public class AsyncPlaceholderCached { + + private final Cache cache; + private final Function> loader; + + public AsyncPlaceholderCached(Function> loader, Duration expireAfterWrite) { + this.loader = loader; + this.cache = CacheBuilder.newBuilder() + .expireAfterWrite(expireAfterWrite) + .build(); + } + + public T getCached(UUID uuid) { + T cached = this.cache.getIfPresent(uuid); + + if (cached != null) { + return cached; + } + + this.loader.apply(uuid).thenAccept(value -> + this.cache.put(uuid, value) + ); + + return null; + } + + public void update(UUID uuid, T value) { + this.cache.put(uuid, value); + } + + public void invalidate(UUID uuid) { + this.cache.invalidate(uuid); + } + + public void clear() { + this.cache.invalidateAll(); + } + + public boolean contains(UUID uuid) { + return this.cache.getIfPresent(uuid) != null; + } +} From 1407a2862f176b5a69b30ffe893f658bdf90e705 Mon Sep 17 00:00:00 2001 From: Piotr Zych <77621271+P1otrulla@users.noreply.github.com> Date: Sun, 12 Oct 2025 13:03:59 +0200 Subject: [PATCH 05/15] Refactor `MsgPlaceholderSetup` to enhance caching with `AsyncPlaceholderCacheRegistry` * Replace individual `stateCache` with dynamically registered cache in the `AsyncPlaceholderCacheRegistry`. * Simplify placeholder setup logic and adjust `MsgToggleService` to utilize the registry for cache management. --- .../core/feature/msg/MsgPlaceholderSetup.java | 35 ++++++++++++------ .../msg/toggle/MsgToggleServiceImpl.java | 36 ++++++++++++------- 2 files changed, 47 insertions(+), 24 deletions(-) diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java index 10f7a29c2..b98b93122 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java @@ -4,33 +4,50 @@ import com.eternalcode.core.feature.msg.toggle.MsgToggleService; import com.eternalcode.core.injector.annotations.Inject; import com.eternalcode.core.injector.annotations.component.Controller; -import com.eternalcode.core.placeholder.cache.AsyncPlaceholderCached; import com.eternalcode.core.placeholder.PlaceholderRegistry; import com.eternalcode.core.placeholder.PlaceholderReplacer; +import com.eternalcode.core.placeholder.cache.AsyncPlaceholderCacheRegistry; +import com.eternalcode.core.placeholder.cache.AsyncPlaceholderCached; import com.eternalcode.core.publish.Subscribe; import com.eternalcode.core.publish.event.EternalInitializeEvent; import com.eternalcode.core.translation.Translation; import com.eternalcode.core.translation.TranslationManager; +import java.time.Duration; import java.util.UUID; @Controller -class MsgPlaceholderSetup { +public class MsgPlaceholderSetup { + + public static final String MSG_STATE_CACHE_KEY = "msg_state"; private final MsgService msgService; + private final MsgToggleService msgToggleService; private final TranslationManager translationManager; - private final AsyncPlaceholderCached stateCache; + private final AsyncPlaceholderCacheRegistry cacheRegistry; @Inject - MsgPlaceholderSetup(MsgService msgService, MsgToggleService msgToggleService, TranslationManager translationManager) { + MsgPlaceholderSetup( + MsgService msgService, + MsgToggleService msgToggleService, + TranslationManager translationManager, + AsyncPlaceholderCacheRegistry cacheRegistry + ) { this.msgService = msgService; + this.msgToggleService = msgToggleService; this.translationManager = translationManager; - this.stateCache = new AsyncPlaceholderCached<>(msgToggleService::getState); + this.cacheRegistry = cacheRegistry; } @Subscribe(EternalInitializeEvent.class) void setUpPlaceholders(PlaceholderRegistry placeholderRegistry) { Translation translation = this.translationManager.getMessages(); + AsyncPlaceholderCached stateCache = this.cacheRegistry.register( + MSG_STATE_CACHE_KEY, + this.msgToggleService::getState, + Duration.ofMinutes(10) + ); + placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( "socialspy_status", player -> String.valueOf(this.msgService.isSpy(player.getUniqueId())) @@ -50,7 +67,7 @@ void setUpPlaceholders(PlaceholderRegistry placeholderRegistry) { "msg_status", player -> { UUID uuid = player.getUniqueId(); - MsgState state = this.stateCache.getCached(uuid); + MsgState state = stateCache.getCached(uuid); if (state == null) { return translation.msg().placeholders().loading(); @@ -64,7 +81,7 @@ void setUpPlaceholders(PlaceholderRegistry placeholderRegistry) { "msg_status_formatted", player -> { UUID uuid = player.getUniqueId(); - MsgState state = this.stateCache.getCached(uuid); + MsgState state = stateCache.getCached(uuid); if (state == null) { return translation.msg().placeholders().loading(); @@ -76,8 +93,4 @@ void setUpPlaceholders(PlaceholderRegistry placeholderRegistry) { } )); } - - public AsyncPlaceholderCached getStateCache() { - return this.stateCache; - } } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleServiceImpl.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleServiceImpl.java index 227d40e5d..066f29324 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleServiceImpl.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleServiceImpl.java @@ -1,41 +1,51 @@ package com.eternalcode.core.feature.msg.toggle; +import com.eternalcode.core.feature.msg.MsgPlaceholderSetup; import com.eternalcode.core.injector.annotations.Inject; import com.eternalcode.core.injector.annotations.component.Service; +import com.eternalcode.core.placeholder.cache.AsyncPlaceholderCacheRegistry; import java.util.UUID; import java.util.concurrent.CompletableFuture; -import java.util.concurrent.ConcurrentHashMap; @Service class MsgToggleServiceImpl implements MsgToggleService { private final MsgToggleRepository msgToggleRepository; - private final ConcurrentHashMap cachedToggleStates; + private final AsyncPlaceholderCacheRegistry cacheRegistry; @Inject - MsgToggleServiceImpl(MsgToggleRepository msgToggleRepository) { - this.cachedToggleStates = new ConcurrentHashMap<>(); + MsgToggleServiceImpl(MsgToggleRepository msgToggleRepository, AsyncPlaceholderCacheRegistry cacheRegistry) { this.msgToggleRepository = msgToggleRepository; - + this.cacheRegistry = cacheRegistry; } - @Override public CompletableFuture getState(UUID playerUniqueId) { - if (this.cachedToggleStates.containsKey(playerUniqueId)) { - return CompletableFuture.completedFuture(this.cachedToggleStates.get(playerUniqueId)); - } - - return this.msgToggleRepository.getPrivateChatState(playerUniqueId); + return this.cacheRegistry.get(MsgPlaceholderSetup.MSG_STATE_CACHE_KEY) + .map(cache -> { + MsgState cached = cache.getCached(playerUniqueId); + if (cached != null) { + return CompletableFuture.completedFuture(cached); + } + + return this.msgToggleRepository.getPrivateChatState(playerUniqueId) + .thenApply(state -> { + cache.update(playerUniqueId, state); + return state; + }); + }) + .orElseGet(() -> this.msgToggleRepository.getPrivateChatState(playerUniqueId)); } @Override public CompletableFuture setState(UUID playerUniqueId, MsgState state) { - this.cachedToggleStates.put(playerUniqueId, state); + this.cacheRegistry.get(MsgPlaceholderSetup.MSG_STATE_CACHE_KEY) + .ifPresent(cache -> cache.update(playerUniqueId, state)); return this.msgToggleRepository.setPrivateChatState(playerUniqueId, state) .exceptionally(throwable -> { - this.cachedToggleStates.remove(playerUniqueId); + this.cacheRegistry.get(MsgPlaceholderSetup.MSG_STATE_CACHE_KEY) + .ifPresent(cache -> cache.invalidate(playerUniqueId)); return null; }); } From a8c66595eba8bb591ca0c8376d136cf566f680c4 Mon Sep 17 00:00:00 2001 From: Piotr Zych <77621271+P1otrulla@users.noreply.github.com> Date: Sun, 12 Oct 2025 13:07:03 +0200 Subject: [PATCH 06/15] Enhance `AsyncPlaceholderCacheController` with event-based cache invalidation * Add `Subscribe` annotations to invalidate cache on `EternalReloadEvent` and `EternalShutdownEvent`. --- .../cache/AsyncPlaceholderCacheController.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheController.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheController.java index bb0c8c6ac..543cdf373 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheController.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheController.java @@ -2,6 +2,9 @@ import com.eternalcode.core.injector.annotations.Inject; import com.eternalcode.core.injector.annotations.component.Controller; +import com.eternalcode.core.publish.Subscribe; +import com.eternalcode.core.publish.event.EternalReloadEvent; +import com.eternalcode.core.publish.event.EternalShutdownEvent; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.Listener; @@ -21,4 +24,14 @@ class AsyncPlaceholderCacheController implements Listener { void onPlayerQuit(PlayerQuitEvent event) { this.cacheRegistry.invalidatePlayer(event.getPlayer().getUniqueId()); } + + @Subscribe + void onEternalDisable(EternalShutdownEvent event) { + this.cacheRegistry.invalidateAll(); + } + + @Subscribe + void onEternalDisable(EternalReloadEvent event) { + this.cacheRegistry.invalidateAll(); + } } From 2633ef6a292375f975c5bd4e8c7005f95efe808a Mon Sep 17 00:00:00 2001 From: Piotr Zych <77621271+P1otrulla@users.noreply.github.com> Date: Sun, 12 Oct 2025 13:07:32 +0200 Subject: [PATCH 07/15] Refactor `AsyncPlaceholderCacheController` event methods * Rename `onEternalDisable` to `onDisable` and `onReload`. --- .../placeholder/cache/AsyncPlaceholderCacheController.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheController.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheController.java index 543cdf373..b8d182a97 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheController.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheController.java @@ -26,12 +26,12 @@ void onPlayerQuit(PlayerQuitEvent event) { } @Subscribe - void onEternalDisable(EternalShutdownEvent event) { + void onDisable(EternalShutdownEvent event) { this.cacheRegistry.invalidateAll(); } @Subscribe - void onEternalDisable(EternalReloadEvent event) { + void onReload(EternalReloadEvent event) { this.cacheRegistry.invalidateAll(); } } From dc6f963d53865bf0681417e49d4a70720b22a298 Mon Sep 17 00:00:00 2001 From: Piotr Zych <77621271+P1otrulla@users.noreply.github.com> Date: Sun, 12 Oct 2025 13:11:56 +0200 Subject: [PATCH 08/15] the bomb was defused xd --- .../core/feature/msg/MsgPlaceholderSetup.java | 10 +++--- .../msg/toggle/MsgToggleRepository.java | 2 +- .../msg/toggle/MsgToggleServiceImpl.java | 35 +++++++++---------- 3 files changed, 23 insertions(+), 24 deletions(-) diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java index b98b93122..959c30d71 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java @@ -1,7 +1,7 @@ package com.eternalcode.core.feature.msg; import com.eternalcode.core.feature.msg.toggle.MsgState; -import com.eternalcode.core.feature.msg.toggle.MsgToggleService; +import com.eternalcode.core.feature.msg.toggle.MsgToggleRepository; import com.eternalcode.core.injector.annotations.Inject; import com.eternalcode.core.injector.annotations.component.Controller; import com.eternalcode.core.placeholder.PlaceholderRegistry; @@ -21,19 +21,19 @@ public class MsgPlaceholderSetup { public static final String MSG_STATE_CACHE_KEY = "msg_state"; private final MsgService msgService; - private final MsgToggleService msgToggleService; + private final MsgToggleRepository msgToggleRepository; private final TranslationManager translationManager; private final AsyncPlaceholderCacheRegistry cacheRegistry; @Inject MsgPlaceholderSetup( MsgService msgService, - MsgToggleService msgToggleService, + MsgToggleRepository msgToggleRepository, TranslationManager translationManager, AsyncPlaceholderCacheRegistry cacheRegistry ) { this.msgService = msgService; - this.msgToggleService = msgToggleService; + this.msgToggleRepository = msgToggleRepository; this.translationManager = translationManager; this.cacheRegistry = cacheRegistry; } @@ -44,7 +44,7 @@ void setUpPlaceholders(PlaceholderRegistry placeholderRegistry) { AsyncPlaceholderCached stateCache = this.cacheRegistry.register( MSG_STATE_CACHE_KEY, - this.msgToggleService::getState, + this.msgToggleRepository::getPrivateChatState, Duration.ofMinutes(10) ); diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleRepository.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleRepository.java index 51c429ae0..3853c49e8 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleRepository.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleRepository.java @@ -4,7 +4,7 @@ import java.util.UUID; import java.util.concurrent.CompletableFuture; -interface MsgToggleRepository { +public interface MsgToggleRepository { CompletableFuture getPrivateChatState(UUID uuid); diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleServiceImpl.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleServiceImpl.java index 066f29324..4fedb03c1 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleServiceImpl.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleServiceImpl.java @@ -21,31 +21,20 @@ class MsgToggleServiceImpl implements MsgToggleService { @Override public CompletableFuture getState(UUID playerUniqueId) { - return this.cacheRegistry.get(MsgPlaceholderSetup.MSG_STATE_CACHE_KEY) - .map(cache -> { - MsgState cached = cache.getCached(playerUniqueId); - if (cached != null) { - return CompletableFuture.completedFuture(cached); - } - - return this.msgToggleRepository.getPrivateChatState(playerUniqueId) - .thenApply(state -> { - cache.update(playerUniqueId, state); - return state; - }); - }) - .orElseGet(() -> this.msgToggleRepository.getPrivateChatState(playerUniqueId)); + return this.msgToggleRepository.getPrivateChatState(playerUniqueId) + .thenApply(state -> { + this.updateCache(playerUniqueId, state); + return state; + }); } @Override public CompletableFuture setState(UUID playerUniqueId, MsgState state) { - this.cacheRegistry.get(MsgPlaceholderSetup.MSG_STATE_CACHE_KEY) - .ifPresent(cache -> cache.update(playerUniqueId, state)); + this.updateCache(playerUniqueId, state); return this.msgToggleRepository.setPrivateChatState(playerUniqueId, state) .exceptionally(throwable -> { - this.cacheRegistry.get(MsgPlaceholderSetup.MSG_STATE_CACHE_KEY) - .ifPresent(cache -> cache.invalidate(playerUniqueId)); + this.invalidateCache(playerUniqueId); return null; }); } @@ -58,4 +47,14 @@ public CompletableFuture toggleState(UUID playerUniqueId) { .thenApply(aVoid -> newState); }); } + + private void updateCache(UUID uuid, MsgState state) { + this.cacheRegistry.get(MsgPlaceholderSetup.MSG_STATE_CACHE_KEY) + .ifPresent(cache -> cache.update(uuid, state)); + } + + private void invalidateCache(UUID uuid) { + this.cacheRegistry.get(MsgPlaceholderSetup.MSG_STATE_CACHE_KEY) + .ifPresent(cache -> cache.invalidate(uuid)); + } } From aa360ddacfe2b9ce9912b21f18b6cd2687ee9f48 Mon Sep 17 00:00:00 2001 From: Piotr Zych <77621271+P1otrulla@users.noreply.github.com> Date: Sun, 12 Oct 2025 13:30:52 +0200 Subject: [PATCH 09/15] Follow gemini comment --- .../placeholder/cache/AsyncPlaceholderCached.java | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCached.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCached.java index b0d05b58d..1e0bcd597 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCached.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCached.java @@ -3,14 +3,17 @@ import com.google.common.cache.Cache; import com.google.common.cache.CacheBuilder; import java.time.Duration; +import java.util.Map; import java.util.UUID; import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ConcurrentHashMap; import java.util.function.Function; public class AsyncPlaceholderCached { private final Cache cache; private final Function> loader; + private final Map> loading = new ConcurrentHashMap<>(); public AsyncPlaceholderCached(Function> loader, Duration expireAfterWrite) { this.loader = loader; @@ -21,18 +24,21 @@ public AsyncPlaceholderCached(Function> loader, Durat public T getCached(UUID uuid) { T cached = this.cache.getIfPresent(uuid); - if (cached != null) { return cached; } - this.loader.apply(uuid).thenAccept(value -> - this.cache.put(uuid, value) + this.loading.computeIfAbsent(uuid, key -> + this.loader.apply(key).whenComplete((value, throwable) -> { + if (value != null) { + this.cache.put(key, value); + } + this.loading.remove(key); + }) ); return null; } - public void update(UUID uuid, T value) { this.cache.put(uuid, value); } From a1281541d4f65631c73b0f9d27f843d43b401ab4 Mon Sep 17 00:00:00 2001 From: Piotr Zych <77621271+P1otrulla@users.noreply.github.com> Date: Sun, 12 Oct 2025 13:49:36 +0200 Subject: [PATCH 10/15] Follow gemini comment --- .../core/feature/msg/MsgPlaceholderSetup.java | 50 +++++++++++-------- .../msg/toggle/MsgToggleServiceImpl.java | 17 +++---- 2 files changed, 36 insertions(+), 31 deletions(-) diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java index 959c30d71..99829ed75 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java @@ -14,6 +14,7 @@ import com.eternalcode.core.translation.TranslationManager; import java.time.Duration; import java.util.UUID; +import java.util.function.Function; @Controller public class MsgPlaceholderSetup { @@ -65,32 +66,39 @@ void setUpPlaceholders(PlaceholderRegistry placeholderRegistry) { placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( "msg_status", - player -> { - UUID uuid = player.getUniqueId(); - MsgState state = stateCache.getCached(uuid); - - if (state == null) { - return translation.msg().placeholders().loading(); - } - - return state.name().toLowerCase(); - } + player -> this.formatMsgState( + player.getUniqueId(), + stateCache, + translation, + state -> state.name().toLowerCase() + ) )); placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( "msg_status_formatted", - player -> { - UUID uuid = player.getUniqueId(); - MsgState state = stateCache.getCached(uuid); - - if (state == null) { - return translation.msg().placeholders().loading(); - } - - return state == MsgState.ENABLED + player -> this.formatMsgState( + player.getUniqueId(), + stateCache, + translation, + state -> state == MsgState.ENABLED ? translation.msg().placeholders().msgEnabled() - : translation.msg().placeholders().msgDisabled(); - } + : translation.msg().placeholders().msgDisabled() + ) )); } + + private String formatMsgState( + UUID uuid, + AsyncPlaceholderCached stateCache, + Translation translation, + Function formatter + ) { + MsgState state = stateCache.getCached(uuid); + + if (state == null) { + return translation.msg().placeholders().loading(); + } + + return formatter.apply(state); + } } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleServiceImpl.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleServiceImpl.java index 4fedb03c1..d3d063523 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleServiceImpl.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleServiceImpl.java @@ -4,8 +4,10 @@ import com.eternalcode.core.injector.annotations.Inject; import com.eternalcode.core.injector.annotations.component.Service; import com.eternalcode.core.placeholder.cache.AsyncPlaceholderCacheRegistry; +import com.eternalcode.core.placeholder.cache.AsyncPlaceholderCached; import java.util.UUID; import java.util.concurrent.CompletableFuture; +import java.util.function.Consumer; @Service class MsgToggleServiceImpl implements MsgToggleService { @@ -23,18 +25,18 @@ class MsgToggleServiceImpl implements MsgToggleService { public CompletableFuture getState(UUID playerUniqueId) { return this.msgToggleRepository.getPrivateChatState(playerUniqueId) .thenApply(state -> { - this.updateCache(playerUniqueId, state); + this.withCache(cache -> cache.update(playerUniqueId, state)); return state; }); } @Override public CompletableFuture setState(UUID playerUniqueId, MsgState state) { - this.updateCache(playerUniqueId, state); + this.withCache(cache -> cache.update(playerUniqueId, state)); return this.msgToggleRepository.setPrivateChatState(playerUniqueId, state) .exceptionally(throwable -> { - this.invalidateCache(playerUniqueId); + this.withCache(cache -> cache.invalidate(playerUniqueId)); return null; }); } @@ -48,13 +50,8 @@ public CompletableFuture toggleState(UUID playerUniqueId) { }); } - private void updateCache(UUID uuid, MsgState state) { + private void withCache(Consumer> action) { this.cacheRegistry.get(MsgPlaceholderSetup.MSG_STATE_CACHE_KEY) - .ifPresent(cache -> cache.update(uuid, state)); - } - - private void invalidateCache(UUID uuid) { - this.cacheRegistry.get(MsgPlaceholderSetup.MSG_STATE_CACHE_KEY) - .ifPresent(cache -> cache.invalidate(uuid)); + .ifPresent(action); } } From 6e7e842f395931faaa4c42e819fb18736786499b Mon Sep 17 00:00:00 2001 From: Rollczi Date: Sat, 21 Feb 2026 16:11:27 +0100 Subject: [PATCH 11/15] CR --- .../core/bridge/BridgeManager.java | 4 +- ...er.java => PlaceholderAPIPlaceholder.java} | 4 +- .../PlaceholderApiExtension.java | 6 +- .../core/feature/afk/AfkPlaceholderSetup.java | 10 +-- .../feature/home/HomePlaceholderSetup.java | 12 ++-- .../core/feature/msg/MsgPlaceholderSetup.java | 67 +++++-------------- .../msg/toggle/MsgToggleRepository.java | 2 +- .../toggle/MsgToggleRepositoryOrmLite.java | 4 +- .../msg/toggle/MsgToggleServiceImpl.java | 36 +++------- .../core/placeholder/NamedPlaceholder.java | 16 +++++ .../core/placeholder/Placeholder.java | 35 ++++++++++ .../core/placeholder/PlaceholderAsync.java | 56 ++++++++++++++++ .../PlaceholderBukkitRegistryImpl.java | 38 ++++++++--- .../core/placeholder/PlaceholderRaw.java | 30 --------- .../core/placeholder/PlaceholderRegistry.java | 8 ++- .../core/placeholder/PlaceholderReplacer.java | 23 ------- .../core/placeholder/PlaceholdersSetup.java | 4 +- .../placeholder/StaticValuePlaceholder.java | 32 +++++++++ .../AsyncPlaceholderCacheController.java | 37 ---------- .../cache/AsyncPlaceholderCacheRegistry.java | 53 --------------- .../cache/AsyncPlaceholderCached.java | 57 ---------------- .../watcher/PlaceholderWatcher.java | 14 ++++ .../watcher/PlaceholderWatcherKey.java | 9 +++ 23 files changed, 249 insertions(+), 308 deletions(-) rename eternalcore-core/src/main/java/com/eternalcode/core/bridge/placeholderapi/{PlaceholderApiReplacer.java => PlaceholderAPIPlaceholder.java} (68%) create mode 100644 eternalcore-core/src/main/java/com/eternalcode/core/placeholder/NamedPlaceholder.java create mode 100644 eternalcore-core/src/main/java/com/eternalcode/core/placeholder/Placeholder.java create mode 100644 eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderAsync.java delete mode 100644 eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderRaw.java delete mode 100644 eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderReplacer.java create mode 100644 eternalcore-core/src/main/java/com/eternalcode/core/placeholder/StaticValuePlaceholder.java delete mode 100644 eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheController.java delete mode 100644 eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheRegistry.java delete mode 100644 eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCached.java create mode 100644 eternalcore-core/src/main/java/com/eternalcode/core/placeholder/watcher/PlaceholderWatcher.java create mode 100644 eternalcore-core/src/main/java/com/eternalcode/core/placeholder/watcher/PlaceholderWatcherKey.java diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/bridge/BridgeManager.java b/eternalcore-core/src/main/java/com/eternalcode/core/bridge/BridgeManager.java index b76f09191..750270bca 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/bridge/BridgeManager.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/bridge/BridgeManager.java @@ -2,7 +2,7 @@ import com.eternalcode.core.bridge.dynmap.DynmapBridgeInitializer; import com.eternalcode.core.bridge.placeholderapi.PlaceholderApiExtension; -import com.eternalcode.core.bridge.placeholderapi.PlaceholderApiReplacer; +import com.eternalcode.core.bridge.placeholderapi.PlaceholderAPIPlaceholder; import com.eternalcode.core.feature.vanish.VanishService; import com.eternalcode.core.placeholder.PlaceholderRegistry; import org.bukkit.Server; @@ -38,7 +38,7 @@ class BridgeManager { void init() { this.setupBridge("PlaceholderAPI", () -> { - this.placeholderRegistry.registerPlaceholder(new PlaceholderApiReplacer()); + this.placeholderRegistry.register(new PlaceholderAPIPlaceholder()); new PlaceholderApiExtension(this.placeholderRegistry, this.pluginDescriptionFile).initialize(); }); diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/bridge/placeholderapi/PlaceholderApiReplacer.java b/eternalcore-core/src/main/java/com/eternalcode/core/bridge/placeholderapi/PlaceholderAPIPlaceholder.java similarity index 68% rename from eternalcore-core/src/main/java/com/eternalcode/core/bridge/placeholderapi/PlaceholderApiReplacer.java rename to eternalcore-core/src/main/java/com/eternalcode/core/bridge/placeholderapi/PlaceholderAPIPlaceholder.java index 8d4dfb08b..5e8ffad77 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/bridge/placeholderapi/PlaceholderApiReplacer.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/bridge/placeholderapi/PlaceholderAPIPlaceholder.java @@ -1,11 +1,11 @@ package com.eternalcode.core.bridge.placeholderapi; -import com.eternalcode.core.placeholder.PlaceholderReplacer; +import com.eternalcode.core.placeholder.Placeholder; import me.clip.placeholderapi.PlaceholderAPI; import org.bukkit.entity.Player; -public class PlaceholderApiReplacer implements PlaceholderReplacer { +public class PlaceholderAPIPlaceholder implements Placeholder { @Override public String apply(String text, Player targetPlayer) { diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/bridge/placeholderapi/PlaceholderApiExtension.java b/eternalcore-core/src/main/java/com/eternalcode/core/bridge/placeholderapi/PlaceholderApiExtension.java index 2eb14ccc6..cca53500f 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/bridge/placeholderapi/PlaceholderApiExtension.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/bridge/placeholderapi/PlaceholderApiExtension.java @@ -1,7 +1,7 @@ package com.eternalcode.core.bridge.placeholderapi; import com.eternalcode.core.bridge.BridgeInitializer; -import com.eternalcode.core.placeholder.PlaceholderRaw; +import com.eternalcode.core.placeholder.NamedPlaceholder; import com.eternalcode.core.placeholder.PlaceholderRegistry; import me.clip.placeholderapi.expansion.PlaceholderExpansion; import org.bukkit.entity.Player; @@ -23,10 +23,10 @@ public PlaceholderApiExtension(PlaceholderRegistry placeholderRegistry, PluginDe @Override public @Nullable String onPlaceholderRequest(Player player, @NotNull String params) { - Optional optional = this.placeholderRegistry.getRawPlaceholder(params); + Optional optional = this.placeholderRegistry.getNamedPlaceholder(params); if (optional.isPresent()) { - return optional.get().rawApply(player); + return optional.get().provideValue(player); } return "Unknown placeholder!"; diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/afk/AfkPlaceholderSetup.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/afk/AfkPlaceholderSetup.java index d27c63541..5698bc79b 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/afk/AfkPlaceholderSetup.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/afk/AfkPlaceholderSetup.java @@ -3,7 +3,7 @@ import com.eternalcode.core.injector.annotations.Inject; import com.eternalcode.core.injector.annotations.component.Controller; import com.eternalcode.core.placeholder.PlaceholderRegistry; -import com.eternalcode.core.placeholder.PlaceholderReplacer; +import com.eternalcode.core.placeholder.Placeholder; import com.eternalcode.core.publish.Subscribe; import com.eternalcode.core.publish.event.EternalInitializeEvent; import com.eternalcode.core.translation.Translation; @@ -28,10 +28,10 @@ class AfkPlaceholderSetup { @Subscribe(EternalInitializeEvent.class) void setUpPlaceholders(PlaceholderRegistry placeholderRegistry, AfkService afkService) { - placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( + placeholderRegistry.register(Placeholder.of( "afk", player -> String.valueOf(afkService.isAfk(player.getUniqueId())))); - placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( + placeholderRegistry.register(Placeholder.of( "afk_formatted", player -> { Translation messages = this.translationManager.getMessages(player.getUniqueId()); @@ -39,7 +39,7 @@ void setUpPlaceholders(PlaceholderRegistry placeholderRegistry, AfkService afkSe messages.afk().afkEnabledPlaceholder() : messages.afk().afkDisabledPlaceholder(); })); - placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( + placeholderRegistry.register(Placeholder.of( "afk_time", player -> { Optional afkOptional = afkService.getAfk(player.getUniqueId()); @@ -54,7 +54,7 @@ void setUpPlaceholders(PlaceholderRegistry placeholderRegistry, AfkService afkSe return DurationUtil.format(afkDuration, true); })); - placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( + placeholderRegistry.register(Placeholder.of( "afk_playercount", player -> { long afkPlayerCount = this.server.getOnlinePlayers() diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/home/HomePlaceholderSetup.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/home/HomePlaceholderSetup.java index f4d695763..76dd7d8c0 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/home/HomePlaceholderSetup.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/home/HomePlaceholderSetup.java @@ -3,7 +3,7 @@ import com.eternalcode.core.injector.annotations.Inject; import com.eternalcode.core.injector.annotations.component.Controller; import com.eternalcode.core.placeholder.PlaceholderRegistry; -import com.eternalcode.core.placeholder.PlaceholderReplacer; +import com.eternalcode.core.placeholder.Placeholder; import com.eternalcode.core.publish.Subscribe; import com.eternalcode.core.publish.event.EternalInitializeEvent; import com.eternalcode.core.translation.Translation; @@ -28,11 +28,11 @@ class HomePlaceholderSetup { @Subscribe(EternalInitializeEvent.class) void setUp(PlaceholderRegistry placeholderRegistry) { Stream.of( - PlaceholderReplacer.of("homes_owned", (text, targetPlayer) -> this.ownedHomes(targetPlayer)), - PlaceholderReplacer.of("homes_count", (text, targetPlayer) -> this.homesCount(targetPlayer)), - PlaceholderReplacer.of("homes_limit", (text, targetPlayer) -> this.homesLimit(targetPlayer)), - PlaceholderReplacer.of("homes_left", (text, targetPlayer) -> this.homesLeft(targetPlayer)) - ).forEach(placeholder -> placeholderRegistry.registerPlaceholder(placeholder)); + Placeholder.of("homes_owned", (text, targetPlayer) -> this.ownedHomes(targetPlayer)), + Placeholder.of("homes_count", (text, targetPlayer) -> this.homesCount(targetPlayer)), + Placeholder.of("homes_limit", (text, targetPlayer) -> this.homesLimit(targetPlayer)), + Placeholder.of("homes_left", (text, targetPlayer) -> this.homesLeft(targetPlayer)) + ).forEach(placeholder -> placeholderRegistry.register(placeholder)); } private String homesLeft(Player targetPlayer) { diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java index 99829ed75..735cafaa5 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java @@ -5,56 +5,44 @@ import com.eternalcode.core.injector.annotations.Inject; import com.eternalcode.core.injector.annotations.component.Controller; import com.eternalcode.core.placeholder.PlaceholderRegistry; -import com.eternalcode.core.placeholder.PlaceholderReplacer; -import com.eternalcode.core.placeholder.cache.AsyncPlaceholderCacheRegistry; -import com.eternalcode.core.placeholder.cache.AsyncPlaceholderCached; +import com.eternalcode.core.placeholder.Placeholder; +import com.eternalcode.core.placeholder.watcher.PlaceholderWatcherKey; import com.eternalcode.core.publish.Subscribe; import com.eternalcode.core.publish.event.EternalInitializeEvent; import com.eternalcode.core.translation.Translation; import com.eternalcode.core.translation.TranslationManager; -import java.time.Duration; import java.util.UUID; -import java.util.function.Function; @Controller public class MsgPlaceholderSetup { - public static final String MSG_STATE_CACHE_KEY = "msg_state"; + public static final PlaceholderWatcherKey MSG_STATE = PlaceholderWatcherKey.of("msg_state", MsgState.class); private final MsgService msgService; private final MsgToggleRepository msgToggleRepository; private final TranslationManager translationManager; - private final AsyncPlaceholderCacheRegistry cacheRegistry; @Inject MsgPlaceholderSetup( MsgService msgService, MsgToggleRepository msgToggleRepository, - TranslationManager translationManager, - AsyncPlaceholderCacheRegistry cacheRegistry + TranslationManager translationManager ) { this.msgService = msgService; this.msgToggleRepository = msgToggleRepository; this.translationManager = translationManager; - this.cacheRegistry = cacheRegistry; } @Subscribe(EternalInitializeEvent.class) - void setUpPlaceholders(PlaceholderRegistry placeholderRegistry) { + void setUpPlaceholders(PlaceholderRegistry registry) { Translation translation = this.translationManager.getMessages(); - AsyncPlaceholderCached stateCache = this.cacheRegistry.register( - MSG_STATE_CACHE_KEY, - this.msgToggleRepository::getPrivateChatState, - Duration.ofMinutes(10) - ); - - placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( + registry.register(Placeholder.of( "socialspy_status", player -> String.valueOf(this.msgService.isSpy(player.getUniqueId())) )); - placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( + registry.register(Placeholder.of( "socialspy_status_formatted", player -> { UUID uuid = player.getUniqueId(); @@ -64,41 +52,22 @@ void setUpPlaceholders(PlaceholderRegistry placeholderRegistry) { } )); - placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( + registry.register(Placeholder.async( "msg_status", - player -> this.formatMsgState( - player.getUniqueId(), - stateCache, - translation, - state -> state.name().toLowerCase() - ) + MSG_STATE, + player -> msgToggleRepository.getPrivateChatState(player), + state -> state.name().toLowerCase() )); - placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( + registry.register(Placeholder.async( "msg_status_formatted", - player -> this.formatMsgState( - player.getUniqueId(), - stateCache, - translation, - state -> state == MsgState.ENABLED - ? translation.msg().placeholders().msgEnabled() - : translation.msg().placeholders().msgDisabled() + MSG_STATE, + player -> msgToggleRepository.getPrivateChatState(player), + state -> state == MsgState.ENABLED + ? translation.msg().placeholders().msgEnabled() + : translation.msg().placeholders().msgDisabled() ) - )); + ); } - private String formatMsgState( - UUID uuid, - AsyncPlaceholderCached stateCache, - Translation translation, - Function formatter - ) { - MsgState state = stateCache.getCached(uuid); - - if (state == null) { - return translation.msg().placeholders().loading(); - } - - return formatter.apply(state); - } } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleRepository.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleRepository.java index 3853c49e8..efc4d6aad 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleRepository.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleRepository.java @@ -8,6 +8,6 @@ public interface MsgToggleRepository { CompletableFuture getPrivateChatState(UUID uuid); - CompletableFuture setPrivateChatState(UUID uuid, MsgState toggledOff); + CompletableFuture setPrivateChatState(UUID uuid, MsgState state); } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleRepositoryOrmLite.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleRepositoryOrmLite.java index effafef03..a28cc7a2b 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleRepositoryOrmLite.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleRepositoryOrmLite.java @@ -28,8 +28,8 @@ public CompletableFuture getPrivateChatState(UUID uuid) { } @Override - public CompletableFuture setPrivateChatState(UUID uuid, MsgState state) { + public CompletableFuture setPrivateChatState(UUID uuid, MsgState state) { return this.save(MsgStateTable.class, new MsgStateTable(uuid, state)) - .thenApply(status -> null); + .thenApply(status -> state); } } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleServiceImpl.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleServiceImpl.java index d3d063523..cf253dea1 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleServiceImpl.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/toggle/MsgToggleServiceImpl.java @@ -3,42 +3,32 @@ import com.eternalcode.core.feature.msg.MsgPlaceholderSetup; import com.eternalcode.core.injector.annotations.Inject; import com.eternalcode.core.injector.annotations.component.Service; -import com.eternalcode.core.placeholder.cache.AsyncPlaceholderCacheRegistry; -import com.eternalcode.core.placeholder.cache.AsyncPlaceholderCached; +import com.eternalcode.core.placeholder.PlaceholderRegistry; +import com.eternalcode.core.placeholder.watcher.PlaceholderWatcher; import java.util.UUID; import java.util.concurrent.CompletableFuture; -import java.util.function.Consumer; @Service class MsgToggleServiceImpl implements MsgToggleService { private final MsgToggleRepository msgToggleRepository; - private final AsyncPlaceholderCacheRegistry cacheRegistry; + private final PlaceholderWatcher watcher; @Inject - MsgToggleServiceImpl(MsgToggleRepository msgToggleRepository, AsyncPlaceholderCacheRegistry cacheRegistry) { + MsgToggleServiceImpl(MsgToggleRepository msgToggleRepository, PlaceholderRegistry registry) { this.msgToggleRepository = msgToggleRepository; - this.cacheRegistry = cacheRegistry; + this.watcher = registry.createWatcher(MsgPlaceholderSetup.MSG_STATE); } @Override - public CompletableFuture getState(UUID playerUniqueId) { - return this.msgToggleRepository.getPrivateChatState(playerUniqueId) - .thenApply(state -> { - this.withCache(cache -> cache.update(playerUniqueId, state)); - return state; - }); + public CompletableFuture getState(UUID player) { + return this.watcher.track(player, this.msgToggleRepository.getPrivateChatState(player)); } @Override - public CompletableFuture setState(UUID playerUniqueId, MsgState state) { - this.withCache(cache -> cache.update(playerUniqueId, state)); - - return this.msgToggleRepository.setPrivateChatState(playerUniqueId, state) - .exceptionally(throwable -> { - this.withCache(cache -> cache.invalidate(playerUniqueId)); - return null; - }); + public CompletableFuture setState(UUID player, MsgState state) { + return this.watcher.track(player, this.msgToggleRepository.setPrivateChatState(player, state)) + .thenApply(unused -> null); } @Override @@ -46,12 +36,8 @@ public CompletableFuture toggleState(UUID playerUniqueId) { return this.getState(playerUniqueId).thenCompose(state -> { MsgState newState = state.invert(); return this.setState(playerUniqueId, newState) - .thenApply(aVoid -> newState); + .thenApply(unused -> newState); }); } - private void withCache(Consumer> action) { - this.cacheRegistry.get(MsgPlaceholderSetup.MSG_STATE_CACHE_KEY) - .ifPresent(action); - } } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/NamedPlaceholder.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/NamedPlaceholder.java new file mode 100644 index 000000000..6df52bac1 --- /dev/null +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/NamedPlaceholder.java @@ -0,0 +1,16 @@ +package com.eternalcode.core.placeholder; + +import org.bukkit.entity.Player; + +public interface NamedPlaceholder extends Placeholder { + + @Override + default String apply(String text, Player targetPlayer) { + return text.replace("{" + this.getName() + "}", this.provideValue(targetPlayer)); + } + + String getName(); + + String provideValue(Player targetPlayer); + +} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/Placeholder.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/Placeholder.java new file mode 100644 index 000000000..6068df1ce --- /dev/null +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/Placeholder.java @@ -0,0 +1,35 @@ +package com.eternalcode.core.placeholder; + +import com.eternalcode.core.placeholder.watcher.PlaceholderWatcherKey; +import java.util.UUID; +import java.util.concurrent.CompletableFuture; +import org.bukkit.entity.Player; + +import java.util.function.Function; + +public interface Placeholder { + + String apply(String text, Player targetPlayer); + + static Placeholder of(String target, String replacement) { + return new StaticValuePlaceholder(target, player -> replacement); + } + + static Placeholder of(String target, Function replacement) { + return new StaticValuePlaceholder(target, replacement); + } + + static Placeholder of(String target, Placeholder placeholder) { + return new StaticValuePlaceholder(target, player -> placeholder.apply(target, player)); + } + + static Placeholder async( + String target, + PlaceholderWatcherKey key, + Function> loading, + Function mapper + ) { + return new PlaceholderAsync<>(target, key, loading, mapper); + } + +} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderAsync.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderAsync.java new file mode 100644 index 000000000..14f0b7a23 --- /dev/null +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderAsync.java @@ -0,0 +1,56 @@ +package com.eternalcode.core.placeholder; + +import com.eternalcode.core.placeholder.watcher.PlaceholderWatcherKey; +import com.github.benmanes.caffeine.cache.AsyncLoadingCache; +import com.github.benmanes.caffeine.cache.Caffeine; +import java.util.UUID; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.TimeUnit; +import java.util.function.Function; +import org.bukkit.entity.Player; + +class PlaceholderAsync implements NamedPlaceholder { + + private final String target; + private final PlaceholderWatcherKey key; + private final AsyncLoadingCache cache; + private final Function mapper; + + public PlaceholderAsync(String target, PlaceholderWatcherKey key, Function> loading, Function mapper) { + this.target = target; + this.key = key; + this.cache = Caffeine.newBuilder() + .refreshAfterWrite(1, TimeUnit.MINUTES) + .buildAsync((player, executor) -> loading.apply(player)); + this.mapper = mapper; + } + + @Override + public String getName() { + return this.target; + } + + public PlaceholderWatcherKey key() { + return key; + } + + @Override + public String apply(String text, Player targetPlayer) { + return text.replace(this.target, this.provideValue(targetPlayer)); + } + + @Override + public String provideValue(Player targetPlayer) { + CompletableFuture future = cache.get(targetPlayer.getUniqueId()); + if (future.isDone() && !future.isCompletedExceptionally()) { + return mapper.apply(future.join()); + } + + return null; + } + + public void update(UUID uuid, T value) { + cache.put(uuid, CompletableFuture.completedFuture(value)); + } + +} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderBukkitRegistryImpl.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderBukkitRegistryImpl.java index 2c733baaa..9a6193b83 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderBukkitRegistryImpl.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderBukkitRegistryImpl.java @@ -2,6 +2,8 @@ import com.eternalcode.core.injector.annotations.Inject; import com.eternalcode.core.injector.annotations.component.Service; +import com.eternalcode.core.placeholder.watcher.PlaceholderWatcher; +import com.eternalcode.core.placeholder.watcher.PlaceholderWatcherKey; import com.eternalcode.core.viewer.Viewer; import org.bukkit.Server; import org.bukkit.entity.Player; @@ -16,8 +18,9 @@ public class PlaceholderBukkitRegistryImpl implements PlaceholderRegistry { private final Server server; - private final Set replacerPlayers = new HashSet<>(); - private final Map rawPlaceholders = new HashMap<>(); + private final Set placeholders = new HashSet<>(); + private final Map namedPlaceholders = new HashMap<>(); + private final Map, Set>> asyncPlaceholders = new HashMap<>(); @Inject public PlaceholderBukkitRegistryImpl(Server server) { @@ -25,12 +28,29 @@ public PlaceholderBukkitRegistryImpl(Server server) { } @Override - public void registerPlaceholder(PlaceholderReplacer stack) { - this.replacerPlayers.add(stack); + public void register(Placeholder placeholder) { + this.placeholders.add(placeholder); - if (stack instanceof PlaceholderRaw raw) { - this.rawPlaceholders.put(raw.getRawTarget(), raw); + if (placeholder instanceof NamedPlaceholder namedPlaceholder) { + this.namedPlaceholders.put(namedPlaceholder.getName(), namedPlaceholder); } + + if (placeholder instanceof PlaceholderAsync placeholderAsync) { + PlaceholderWatcherKey key = placeholderAsync.key(); + this.asyncPlaceholders.computeIfAbsent(key, k -> new HashSet<>()).add(placeholderAsync); + } + } + + @Override + @SuppressWarnings("unchecked") + public PlaceholderWatcher createWatcher(PlaceholderWatcherKey key) { + return (player, value) -> { + PlaceholderAsync async = (PlaceholderAsync) asyncPlaceholders.get(key); + if (async != null) { + async.update(player, value); + } + return value; + }; } @Override @@ -39,7 +59,7 @@ public String format(String text, Viewer target) { Player playerTarget = this.server.getPlayer(target.getUniqueId()); if (playerTarget != null) { - for (PlaceholderReplacer replacer : this.replacerPlayers) { + for (Placeholder replacer : this.placeholders) { text = replacer.apply(text, playerTarget); } } @@ -49,8 +69,8 @@ public String format(String text, Viewer target) { } @Override - public Optional getRawPlaceholder(String target) { - return Optional.ofNullable(this.rawPlaceholders.get(target)); + public Optional getNamedPlaceholder(String name) { + return Optional.ofNullable(this.namedPlaceholders.get(name)); } } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderRaw.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderRaw.java deleted file mode 100644 index 3e3febdaf..000000000 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderRaw.java +++ /dev/null @@ -1,30 +0,0 @@ -package com.eternalcode.core.placeholder; - -import org.bukkit.entity.Player; - -import java.util.function.Function; - -public final class PlaceholderRaw implements PlaceholderReplacer { - - private final String target; - private final Function replacement; - - PlaceholderRaw(String target, Function replacement) { - this.target = target; - this.replacement = replacement; - } - - @Override - public String apply(String text, Player targetPlayer) { - return text.replace("{" + this.target + "}", this.replacement.apply(targetPlayer)); - } - - public String getRawTarget() { - return this.target; - } - - public String rawApply(Player targetPlayer) { - return this.replacement.apply(targetPlayer); - } - -} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderRegistry.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderRegistry.java index 82b6d0a8e..1049d7b64 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderRegistry.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderRegistry.java @@ -1,15 +1,19 @@ package com.eternalcode.core.placeholder; +import com.eternalcode.core.placeholder.watcher.PlaceholderWatcher; +import com.eternalcode.core.placeholder.watcher.PlaceholderWatcherKey; import com.eternalcode.core.viewer.Viewer; import java.util.Optional; public interface PlaceholderRegistry { - void registerPlaceholder(PlaceholderReplacer stack); + void register(Placeholder placeholder); + + PlaceholderWatcher createWatcher(PlaceholderWatcherKey name); String format(String text, Viewer target); - Optional getRawPlaceholder(String target); + Optional getNamedPlaceholder(String name); } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderReplacer.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderReplacer.java deleted file mode 100644 index 3c00c992b..000000000 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderReplacer.java +++ /dev/null @@ -1,23 +0,0 @@ -package com.eternalcode.core.placeholder; - -import org.bukkit.entity.Player; - -import java.util.function.Function; - -public interface PlaceholderReplacer { - - String apply(String text, Player targetPlayer); - - static PlaceholderReplacer of(String target, String replacement) { - return new PlaceholderRaw(target, player -> replacement); - } - - static PlaceholderReplacer of(String target, Function replacement) { - return new PlaceholderRaw(target, replacement); - } - - static PlaceholderReplacer of(String target, PlaceholderReplacer placeholder) { - return new PlaceholderRaw(target, player -> placeholder.apply(target, player)); - } - -} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholdersSetup.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholdersSetup.java index 1ddc827ce..5d6cf2dfb 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholdersSetup.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholdersSetup.java @@ -13,13 +13,13 @@ class PlaceholdersSetup { @Subscribe(EternalInitializeEvent.class) void setUp(PlaceholderRegistry placeholderRegistry, PlaceholdersConfiguration placeholdersConfiguration) { placeholdersConfiguration.placeholders.forEach((key, value) -> { - placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of(key, value)); + placeholderRegistry.register(Placeholder.of(key, value)); }); } @Subscribe(EternalInitializeEvent.class) void setUpPlaceholders(PlaceholderRegistry placeholderRegistry, Server server, VanishService vanishService) { - placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of("online", player -> String.valueOf( + placeholderRegistry.register(Placeholder.of("online", player -> String.valueOf( server.getOnlinePlayers() .stream() .filter(onlinePlayer -> !vanishService.isVanished(onlinePlayer)) diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/StaticValuePlaceholder.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/StaticValuePlaceholder.java new file mode 100644 index 000000000..114cc9d7e --- /dev/null +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/StaticValuePlaceholder.java @@ -0,0 +1,32 @@ +package com.eternalcode.core.placeholder; + +import org.bukkit.entity.Player; + +import java.util.function.Function; + +class StaticValuePlaceholder implements NamedPlaceholder { + + private final String name; + private final Function replacement; + + StaticValuePlaceholder(String name, Function replacement) { + this.name = name; + this.replacement = replacement; + } + + @Override + public String apply(String text, Player targetPlayer) { + return text.replace("{" + this.name + "}", this.replacement.apply(targetPlayer)); + } + + @Override + public String getName() { + return this.name; + } + + @Override + public String provideValue(Player targetPlayer) { + return this.replacement.apply(targetPlayer); + } + +} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheController.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheController.java deleted file mode 100644 index b8d182a97..000000000 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheController.java +++ /dev/null @@ -1,37 +0,0 @@ -package com.eternalcode.core.placeholder.cache; - -import com.eternalcode.core.injector.annotations.Inject; -import com.eternalcode.core.injector.annotations.component.Controller; -import com.eternalcode.core.publish.Subscribe; -import com.eternalcode.core.publish.event.EternalReloadEvent; -import com.eternalcode.core.publish.event.EternalShutdownEvent; -import org.bukkit.event.EventHandler; -import org.bukkit.event.EventPriority; -import org.bukkit.event.Listener; -import org.bukkit.event.player.PlayerQuitEvent; - -@Controller -class AsyncPlaceholderCacheController implements Listener { - - private final AsyncPlaceholderCacheRegistry cacheRegistry; - - @Inject - AsyncPlaceholderCacheController(AsyncPlaceholderCacheRegistry cacheRegistry) { - this.cacheRegistry = cacheRegistry; - } - - @EventHandler(priority = EventPriority.MONITOR) - void onPlayerQuit(PlayerQuitEvent event) { - this.cacheRegistry.invalidatePlayer(event.getPlayer().getUniqueId()); - } - - @Subscribe - void onDisable(EternalShutdownEvent event) { - this.cacheRegistry.invalidateAll(); - } - - @Subscribe - void onReload(EternalReloadEvent event) { - this.cacheRegistry.invalidateAll(); - } -} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheRegistry.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheRegistry.java deleted file mode 100644 index 7b20a99b4..000000000 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCacheRegistry.java +++ /dev/null @@ -1,53 +0,0 @@ -package com.eternalcode.core.placeholder.cache; - -import com.eternalcode.core.injector.annotations.Inject; -import com.eternalcode.core.injector.annotations.component.Service; -import java.time.Duration; -import java.util.Map; -import java.util.Optional; -import java.util.UUID; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.ConcurrentHashMap; -import java.util.function.Function; - -@Service -public class AsyncPlaceholderCacheRegistry { - - private static final Duration DEFAULT_EXPIRE_DURATION = Duration.ofMinutes(30); - - private final Map> caches = new ConcurrentHashMap<>(); - - @Inject - public AsyncPlaceholderCacheRegistry() { - } - - public AsyncPlaceholderCached register(String key, Function> loader) { - return this.register(key, loader, DEFAULT_EXPIRE_DURATION); - } - - public AsyncPlaceholderCached register(String key, Function> loader, Duration expireAfterWrite) { - AsyncPlaceholderCached cache = new AsyncPlaceholderCached<>(loader, expireAfterWrite); - this.caches.put(key, cache); - return cache; - } - - @SuppressWarnings("unchecked") - public Optional> get(String key) { - return Optional.ofNullable((AsyncPlaceholderCached) this.caches.get(key)); - } - - public void invalidatePlayer(UUID uuid) { - this.caches.values().forEach(cache -> cache.invalidate(uuid)); - } - - public void invalidateAll() { - this.caches.values().forEach(AsyncPlaceholderCached::clear); - } - - public void unregister(String key) { - AsyncPlaceholderCached cache = this.caches.remove(key); - if (cache != null) { - cache.clear(); - } - } -} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCached.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCached.java deleted file mode 100644 index 1e0bcd597..000000000 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/cache/AsyncPlaceholderCached.java +++ /dev/null @@ -1,57 +0,0 @@ -package com.eternalcode.core.placeholder.cache; - -import com.google.common.cache.Cache; -import com.google.common.cache.CacheBuilder; -import java.time.Duration; -import java.util.Map; -import java.util.UUID; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.ConcurrentHashMap; -import java.util.function.Function; - -public class AsyncPlaceholderCached { - - private final Cache cache; - private final Function> loader; - private final Map> loading = new ConcurrentHashMap<>(); - - public AsyncPlaceholderCached(Function> loader, Duration expireAfterWrite) { - this.loader = loader; - this.cache = CacheBuilder.newBuilder() - .expireAfterWrite(expireAfterWrite) - .build(); - } - - public T getCached(UUID uuid) { - T cached = this.cache.getIfPresent(uuid); - if (cached != null) { - return cached; - } - - this.loading.computeIfAbsent(uuid, key -> - this.loader.apply(key).whenComplete((value, throwable) -> { - if (value != null) { - this.cache.put(key, value); - } - this.loading.remove(key); - }) - ); - - return null; - } - public void update(UUID uuid, T value) { - this.cache.put(uuid, value); - } - - public void invalidate(UUID uuid) { - this.cache.invalidate(uuid); - } - - public void clear() { - this.cache.invalidateAll(); - } - - public boolean contains(UUID uuid) { - return this.cache.getIfPresent(uuid) != null; - } -} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/watcher/PlaceholderWatcher.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/watcher/PlaceholderWatcher.java new file mode 100644 index 000000000..18ace9a69 --- /dev/null +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/watcher/PlaceholderWatcher.java @@ -0,0 +1,14 @@ +package com.eternalcode.core.placeholder.watcher; + +import java.util.UUID; +import java.util.concurrent.CompletableFuture; + +public interface PlaceholderWatcher { + + T track(UUID player, T value); + + default CompletableFuture track(UUID player, CompletableFuture value) { + return value.thenApply(tracked -> this.track(player, tracked)); + } + +} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/watcher/PlaceholderWatcherKey.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/watcher/PlaceholderWatcherKey.java new file mode 100644 index 000000000..d62482035 --- /dev/null +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/watcher/PlaceholderWatcherKey.java @@ -0,0 +1,9 @@ +package com.eternalcode.core.placeholder.watcher; + +public record PlaceholderWatcherKey(String name, Class type) { + + public static PlaceholderWatcherKey of(String name, Class type) { + return new PlaceholderWatcherKey<>(name, type); + } + +} From 81b610e80d8a83693381923aacca1c289d0c0db1 Mon Sep 17 00:00:00 2001 From: Rollczi Date: Sat, 21 Feb 2026 16:14:39 +0100 Subject: [PATCH 12/15] CR --- .../java/com/eternalcode/core/bridge/BridgeManager.java | 2 +- .../eternalcode/core/feature/afk/AfkPlaceholderSetup.java | 8 ++++---- .../core/feature/home/HomePlaceholderSetup.java | 2 +- .../eternalcode/core/feature/msg/MsgPlaceholderSetup.java | 8 ++++---- .../core/placeholder/PlaceholderBukkitRegistryImpl.java | 2 +- .../eternalcode/core/placeholder/PlaceholderRegistry.java | 2 +- .../eternalcode/core/placeholder/PlaceholdersSetup.java | 4 ++-- 7 files changed, 14 insertions(+), 14 deletions(-) diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/bridge/BridgeManager.java b/eternalcore-core/src/main/java/com/eternalcode/core/bridge/BridgeManager.java index 750270bca..4014430f9 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/bridge/BridgeManager.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/bridge/BridgeManager.java @@ -38,7 +38,7 @@ class BridgeManager { void init() { this.setupBridge("PlaceholderAPI", () -> { - this.placeholderRegistry.register(new PlaceholderAPIPlaceholder()); + this.placeholderRegistry.registerPlaceholder(new PlaceholderAPIPlaceholder()); new PlaceholderApiExtension(this.placeholderRegistry, this.pluginDescriptionFile).initialize(); }); diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/afk/AfkPlaceholderSetup.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/afk/AfkPlaceholderSetup.java index 5698bc79b..d92b032ed 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/afk/AfkPlaceholderSetup.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/afk/AfkPlaceholderSetup.java @@ -28,10 +28,10 @@ class AfkPlaceholderSetup { @Subscribe(EternalInitializeEvent.class) void setUpPlaceholders(PlaceholderRegistry placeholderRegistry, AfkService afkService) { - placeholderRegistry.register(Placeholder.of( + placeholderRegistry.registerPlaceholder(Placeholder.of( "afk", player -> String.valueOf(afkService.isAfk(player.getUniqueId())))); - placeholderRegistry.register(Placeholder.of( + placeholderRegistry.registerPlaceholder(Placeholder.of( "afk_formatted", player -> { Translation messages = this.translationManager.getMessages(player.getUniqueId()); @@ -39,7 +39,7 @@ void setUpPlaceholders(PlaceholderRegistry placeholderRegistry, AfkService afkSe messages.afk().afkEnabledPlaceholder() : messages.afk().afkDisabledPlaceholder(); })); - placeholderRegistry.register(Placeholder.of( + placeholderRegistry.registerPlaceholder(Placeholder.of( "afk_time", player -> { Optional afkOptional = afkService.getAfk(player.getUniqueId()); @@ -54,7 +54,7 @@ void setUpPlaceholders(PlaceholderRegistry placeholderRegistry, AfkService afkSe return DurationUtil.format(afkDuration, true); })); - placeholderRegistry.register(Placeholder.of( + placeholderRegistry.registerPlaceholder(Placeholder.of( "afk_playercount", player -> { long afkPlayerCount = this.server.getOnlinePlayers() diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/home/HomePlaceholderSetup.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/home/HomePlaceholderSetup.java index 76dd7d8c0..f65e1c200 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/home/HomePlaceholderSetup.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/home/HomePlaceholderSetup.java @@ -32,7 +32,7 @@ void setUp(PlaceholderRegistry placeholderRegistry) { Placeholder.of("homes_count", (text, targetPlayer) -> this.homesCount(targetPlayer)), Placeholder.of("homes_limit", (text, targetPlayer) -> this.homesLimit(targetPlayer)), Placeholder.of("homes_left", (text, targetPlayer) -> this.homesLeft(targetPlayer)) - ).forEach(placeholder -> placeholderRegistry.register(placeholder)); + ).forEach(placeholder -> placeholderRegistry.registerPlaceholder(placeholder)); } private String homesLeft(Player targetPlayer) { diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java index 735cafaa5..161c52b45 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java @@ -37,12 +37,12 @@ public class MsgPlaceholderSetup { void setUpPlaceholders(PlaceholderRegistry registry) { Translation translation = this.translationManager.getMessages(); - registry.register(Placeholder.of( + registry.registerPlaceholder(Placeholder.of( "socialspy_status", player -> String.valueOf(this.msgService.isSpy(player.getUniqueId())) )); - registry.register(Placeholder.of( + registry.registerPlaceholder(Placeholder.of( "socialspy_status_formatted", player -> { UUID uuid = player.getUniqueId(); @@ -52,14 +52,14 @@ void setUpPlaceholders(PlaceholderRegistry registry) { } )); - registry.register(Placeholder.async( + registry.registerPlaceholder(Placeholder.async( "msg_status", MSG_STATE, player -> msgToggleRepository.getPrivateChatState(player), state -> state.name().toLowerCase() )); - registry.register(Placeholder.async( + registry.registerPlaceholder(Placeholder.async( "msg_status_formatted", MSG_STATE, player -> msgToggleRepository.getPrivateChatState(player), diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderBukkitRegistryImpl.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderBukkitRegistryImpl.java index 9a6193b83..660988dd4 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderBukkitRegistryImpl.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderBukkitRegistryImpl.java @@ -28,7 +28,7 @@ public PlaceholderBukkitRegistryImpl(Server server) { } @Override - public void register(Placeholder placeholder) { + public void registerPlaceholder(Placeholder placeholder) { this.placeholders.add(placeholder); if (placeholder instanceof NamedPlaceholder namedPlaceholder) { diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderRegistry.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderRegistry.java index 1049d7b64..077fb452a 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderRegistry.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderRegistry.java @@ -8,7 +8,7 @@ public interface PlaceholderRegistry { - void register(Placeholder placeholder); + void registerPlaceholder(Placeholder placeholder); PlaceholderWatcher createWatcher(PlaceholderWatcherKey name); diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholdersSetup.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholdersSetup.java index 5d6cf2dfb..fd9d4a70d 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholdersSetup.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholdersSetup.java @@ -13,13 +13,13 @@ class PlaceholdersSetup { @Subscribe(EternalInitializeEvent.class) void setUp(PlaceholderRegistry placeholderRegistry, PlaceholdersConfiguration placeholdersConfiguration) { placeholdersConfiguration.placeholders.forEach((key, value) -> { - placeholderRegistry.register(Placeholder.of(key, value)); + placeholderRegistry.registerPlaceholder(Placeholder.of(key, value)); }); } @Subscribe(EternalInitializeEvent.class) void setUpPlaceholders(PlaceholderRegistry placeholderRegistry, Server server, VanishService vanishService) { - placeholderRegistry.register(Placeholder.of("online", player -> String.valueOf( + placeholderRegistry.registerPlaceholder(Placeholder.of("online", player -> String.valueOf( server.getOnlinePlayers() .stream() .filter(onlinePlayer -> !vanishService.isVanished(onlinePlayer)) From 450a2d737b5fdb9ce08a2ed02a50542c52dd6c52 Mon Sep 17 00:00:00 2001 From: Rollczi Date: Sat, 21 Feb 2026 16:15:39 +0100 Subject: [PATCH 13/15] CR --- .../placeholderapi/PlaceholderAPIPlaceholder.java | 4 ++-- .../core/feature/afk/AfkPlaceholderSetup.java | 10 +++++----- .../core/feature/home/HomePlaceholderSetup.java | 10 +++++----- .../core/feature/msg/MsgPlaceholderSetup.java | 10 +++++----- .../eternalcode/core/placeholder/NamedPlaceholder.java | 2 +- .../placeholder/PlaceholderBukkitRegistryImpl.java | 6 +++--- .../core/placeholder/PlaceholderRegistry.java | 2 +- .../{Placeholder.java => PlaceholderReplacer.java} | 10 +++++----- .../core/placeholder/PlaceholdersSetup.java | 4 ++-- 9 files changed, 29 insertions(+), 29 deletions(-) rename eternalcore-core/src/main/java/com/eternalcode/core/placeholder/{Placeholder.java => PlaceholderReplacer.java} (71%) diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/bridge/placeholderapi/PlaceholderAPIPlaceholder.java b/eternalcore-core/src/main/java/com/eternalcode/core/bridge/placeholderapi/PlaceholderAPIPlaceholder.java index 5e8ffad77..760dc5812 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/bridge/placeholderapi/PlaceholderAPIPlaceholder.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/bridge/placeholderapi/PlaceholderAPIPlaceholder.java @@ -1,11 +1,11 @@ package com.eternalcode.core.bridge.placeholderapi; -import com.eternalcode.core.placeholder.Placeholder; +import com.eternalcode.core.placeholder.PlaceholderReplacer; import me.clip.placeholderapi.PlaceholderAPI; import org.bukkit.entity.Player; -public class PlaceholderAPIPlaceholder implements Placeholder { +public class PlaceholderAPIPlaceholder implements PlaceholderReplacer { @Override public String apply(String text, Player targetPlayer) { diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/afk/AfkPlaceholderSetup.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/afk/AfkPlaceholderSetup.java index d92b032ed..d27c63541 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/afk/AfkPlaceholderSetup.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/afk/AfkPlaceholderSetup.java @@ -3,7 +3,7 @@ import com.eternalcode.core.injector.annotations.Inject; import com.eternalcode.core.injector.annotations.component.Controller; import com.eternalcode.core.placeholder.PlaceholderRegistry; -import com.eternalcode.core.placeholder.Placeholder; +import com.eternalcode.core.placeholder.PlaceholderReplacer; import com.eternalcode.core.publish.Subscribe; import com.eternalcode.core.publish.event.EternalInitializeEvent; import com.eternalcode.core.translation.Translation; @@ -28,10 +28,10 @@ class AfkPlaceholderSetup { @Subscribe(EternalInitializeEvent.class) void setUpPlaceholders(PlaceholderRegistry placeholderRegistry, AfkService afkService) { - placeholderRegistry.registerPlaceholder(Placeholder.of( + placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( "afk", player -> String.valueOf(afkService.isAfk(player.getUniqueId())))); - placeholderRegistry.registerPlaceholder(Placeholder.of( + placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( "afk_formatted", player -> { Translation messages = this.translationManager.getMessages(player.getUniqueId()); @@ -39,7 +39,7 @@ void setUpPlaceholders(PlaceholderRegistry placeholderRegistry, AfkService afkSe messages.afk().afkEnabledPlaceholder() : messages.afk().afkDisabledPlaceholder(); })); - placeholderRegistry.registerPlaceholder(Placeholder.of( + placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( "afk_time", player -> { Optional afkOptional = afkService.getAfk(player.getUniqueId()); @@ -54,7 +54,7 @@ void setUpPlaceholders(PlaceholderRegistry placeholderRegistry, AfkService afkSe return DurationUtil.format(afkDuration, true); })); - placeholderRegistry.registerPlaceholder(Placeholder.of( + placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of( "afk_playercount", player -> { long afkPlayerCount = this.server.getOnlinePlayers() diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/home/HomePlaceholderSetup.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/home/HomePlaceholderSetup.java index f65e1c200..f4d695763 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/home/HomePlaceholderSetup.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/home/HomePlaceholderSetup.java @@ -3,7 +3,7 @@ import com.eternalcode.core.injector.annotations.Inject; import com.eternalcode.core.injector.annotations.component.Controller; import com.eternalcode.core.placeholder.PlaceholderRegistry; -import com.eternalcode.core.placeholder.Placeholder; +import com.eternalcode.core.placeholder.PlaceholderReplacer; import com.eternalcode.core.publish.Subscribe; import com.eternalcode.core.publish.event.EternalInitializeEvent; import com.eternalcode.core.translation.Translation; @@ -28,10 +28,10 @@ class HomePlaceholderSetup { @Subscribe(EternalInitializeEvent.class) void setUp(PlaceholderRegistry placeholderRegistry) { Stream.of( - Placeholder.of("homes_owned", (text, targetPlayer) -> this.ownedHomes(targetPlayer)), - Placeholder.of("homes_count", (text, targetPlayer) -> this.homesCount(targetPlayer)), - Placeholder.of("homes_limit", (text, targetPlayer) -> this.homesLimit(targetPlayer)), - Placeholder.of("homes_left", (text, targetPlayer) -> this.homesLeft(targetPlayer)) + PlaceholderReplacer.of("homes_owned", (text, targetPlayer) -> this.ownedHomes(targetPlayer)), + PlaceholderReplacer.of("homes_count", (text, targetPlayer) -> this.homesCount(targetPlayer)), + PlaceholderReplacer.of("homes_limit", (text, targetPlayer) -> this.homesLimit(targetPlayer)), + PlaceholderReplacer.of("homes_left", (text, targetPlayer) -> this.homesLeft(targetPlayer)) ).forEach(placeholder -> placeholderRegistry.registerPlaceholder(placeholder)); } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java index 161c52b45..f3531871a 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java @@ -5,7 +5,7 @@ import com.eternalcode.core.injector.annotations.Inject; import com.eternalcode.core.injector.annotations.component.Controller; import com.eternalcode.core.placeholder.PlaceholderRegistry; -import com.eternalcode.core.placeholder.Placeholder; +import com.eternalcode.core.placeholder.PlaceholderReplacer; import com.eternalcode.core.placeholder.watcher.PlaceholderWatcherKey; import com.eternalcode.core.publish.Subscribe; import com.eternalcode.core.publish.event.EternalInitializeEvent; @@ -37,12 +37,12 @@ public class MsgPlaceholderSetup { void setUpPlaceholders(PlaceholderRegistry registry) { Translation translation = this.translationManager.getMessages(); - registry.registerPlaceholder(Placeholder.of( + registry.registerPlaceholder(PlaceholderReplacer.of( "socialspy_status", player -> String.valueOf(this.msgService.isSpy(player.getUniqueId())) )); - registry.registerPlaceholder(Placeholder.of( + registry.registerPlaceholder(PlaceholderReplacer.of( "socialspy_status_formatted", player -> { UUID uuid = player.getUniqueId(); @@ -52,14 +52,14 @@ void setUpPlaceholders(PlaceholderRegistry registry) { } )); - registry.registerPlaceholder(Placeholder.async( + registry.registerPlaceholder(PlaceholderReplacer.async( "msg_status", MSG_STATE, player -> msgToggleRepository.getPrivateChatState(player), state -> state.name().toLowerCase() )); - registry.registerPlaceholder(Placeholder.async( + registry.registerPlaceholder(PlaceholderReplacer.async( "msg_status_formatted", MSG_STATE, player -> msgToggleRepository.getPrivateChatState(player), diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/NamedPlaceholder.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/NamedPlaceholder.java index 6df52bac1..b0676dc73 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/NamedPlaceholder.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/NamedPlaceholder.java @@ -2,7 +2,7 @@ import org.bukkit.entity.Player; -public interface NamedPlaceholder extends Placeholder { +public interface NamedPlaceholder extends PlaceholderReplacer { @Override default String apply(String text, Player targetPlayer) { diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderBukkitRegistryImpl.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderBukkitRegistryImpl.java index 660988dd4..bf03a00d7 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderBukkitRegistryImpl.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderBukkitRegistryImpl.java @@ -18,7 +18,7 @@ public class PlaceholderBukkitRegistryImpl implements PlaceholderRegistry { private final Server server; - private final Set placeholders = new HashSet<>(); + private final Set placeholders = new HashSet<>(); private final Map namedPlaceholders = new HashMap<>(); private final Map, Set>> asyncPlaceholders = new HashMap<>(); @@ -28,7 +28,7 @@ public PlaceholderBukkitRegistryImpl(Server server) { } @Override - public void registerPlaceholder(Placeholder placeholder) { + public void registerPlaceholder(PlaceholderReplacer placeholder) { this.placeholders.add(placeholder); if (placeholder instanceof NamedPlaceholder namedPlaceholder) { @@ -59,7 +59,7 @@ public String format(String text, Viewer target) { Player playerTarget = this.server.getPlayer(target.getUniqueId()); if (playerTarget != null) { - for (Placeholder replacer : this.placeholders) { + for (PlaceholderReplacer replacer : this.placeholders) { text = replacer.apply(text, playerTarget); } } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderRegistry.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderRegistry.java index 077fb452a..7e58374f7 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderRegistry.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderRegistry.java @@ -8,7 +8,7 @@ public interface PlaceholderRegistry { - void registerPlaceholder(Placeholder placeholder); + void registerPlaceholder(PlaceholderReplacer placeholder); PlaceholderWatcher createWatcher(PlaceholderWatcherKey name); diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/Placeholder.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderReplacer.java similarity index 71% rename from eternalcore-core/src/main/java/com/eternalcode/core/placeholder/Placeholder.java rename to eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderReplacer.java index 6068df1ce..b0f5b40ed 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/Placeholder.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderReplacer.java @@ -7,23 +7,23 @@ import java.util.function.Function; -public interface Placeholder { +public interface PlaceholderReplacer { String apply(String text, Player targetPlayer); - static Placeholder of(String target, String replacement) { + static PlaceholderReplacer of(String target, String replacement) { return new StaticValuePlaceholder(target, player -> replacement); } - static Placeholder of(String target, Function replacement) { + static PlaceholderReplacer of(String target, Function replacement) { return new StaticValuePlaceholder(target, replacement); } - static Placeholder of(String target, Placeholder placeholder) { + static PlaceholderReplacer of(String target, PlaceholderReplacer placeholder) { return new StaticValuePlaceholder(target, player -> placeholder.apply(target, player)); } - static Placeholder async( + static PlaceholderReplacer async( String target, PlaceholderWatcherKey key, Function> loading, diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholdersSetup.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholdersSetup.java index fd9d4a70d..1ddc827ce 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholdersSetup.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholdersSetup.java @@ -13,13 +13,13 @@ class PlaceholdersSetup { @Subscribe(EternalInitializeEvent.class) void setUp(PlaceholderRegistry placeholderRegistry, PlaceholdersConfiguration placeholdersConfiguration) { placeholdersConfiguration.placeholders.forEach((key, value) -> { - placeholderRegistry.registerPlaceholder(Placeholder.of(key, value)); + placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of(key, value)); }); } @Subscribe(EternalInitializeEvent.class) void setUpPlaceholders(PlaceholderRegistry placeholderRegistry, Server server, VanishService vanishService) { - placeholderRegistry.registerPlaceholder(Placeholder.of("online", player -> String.valueOf( + placeholderRegistry.registerPlaceholder(PlaceholderReplacer.of("online", player -> String.valueOf( server.getOnlinePlayers() .stream() .filter(onlinePlayer -> !vanishService.isVanished(onlinePlayer)) From 9f0d5ebb5faded254083ece4553428af2fa872a0 Mon Sep 17 00:00:00 2001 From: Rollczi Date: Sat, 21 Feb 2026 16:16:26 +0100 Subject: [PATCH 14/15] CR --- .../{StaticValuePlaceholder.java => PlaceholderRaw.java} | 4 ++-- .../eternalcode/core/placeholder/PlaceholderReplacer.java | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-) rename eternalcore-core/src/main/java/com/eternalcode/core/placeholder/{StaticValuePlaceholder.java => PlaceholderRaw.java} (82%) diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/StaticValuePlaceholder.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderRaw.java similarity index 82% rename from eternalcore-core/src/main/java/com/eternalcode/core/placeholder/StaticValuePlaceholder.java rename to eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderRaw.java index 114cc9d7e..b98950942 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/StaticValuePlaceholder.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderRaw.java @@ -4,12 +4,12 @@ import java.util.function.Function; -class StaticValuePlaceholder implements NamedPlaceholder { +class PlaceholderRaw implements NamedPlaceholder { private final String name; private final Function replacement; - StaticValuePlaceholder(String name, Function replacement) { + PlaceholderRaw(String name, Function replacement) { this.name = name; this.replacement = replacement; } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderReplacer.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderReplacer.java index b0f5b40ed..10e700c88 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderReplacer.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderReplacer.java @@ -12,15 +12,15 @@ public interface PlaceholderReplacer { String apply(String text, Player targetPlayer); static PlaceholderReplacer of(String target, String replacement) { - return new StaticValuePlaceholder(target, player -> replacement); + return new PlaceholderRaw(target, player -> replacement); } static PlaceholderReplacer of(String target, Function replacement) { - return new StaticValuePlaceholder(target, replacement); + return new PlaceholderRaw(target, replacement); } static PlaceholderReplacer of(String target, PlaceholderReplacer placeholder) { - return new StaticValuePlaceholder(target, player -> placeholder.apply(target, player)); + return new PlaceholderRaw(target, player -> placeholder.apply(target, player)); } static PlaceholderReplacer async( From 082e063e5ee43d6fab5d18e7bd79ab493ecc6617 Mon Sep 17 00:00:00 2001 From: Rollczi Date: Sat, 21 Feb 2026 16:20:03 +0100 Subject: [PATCH 15/15] CR --- .../PlaceholderAPIPlaceholder.java | 1 - .../afk/placeholder/AfkPlaceholderSetup.java | 1 - .../feature/home/HomePlaceholderSetup.java | 1 - .../core/feature/msg/MsgPlaceholderSetup.java | 10 +++--- .../core/placeholder/NamedPlaceholder.java | 2 +- .../core/placeholder/Placeholder.java | 24 +++++++++---- .../PlaceholderBukkitRegistryImpl.java | 4 +-- .../core/placeholder/PlaceholderReplacer.java | 35 ------------------- ...erRaw.java => StaticValuePlaceholder.java} | 4 +-- 9 files changed, 28 insertions(+), 54 deletions(-) delete mode 100644 eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderReplacer.java rename eternalcore-core/src/main/java/com/eternalcode/core/placeholder/{PlaceholderRaw.java => StaticValuePlaceholder.java} (82%) diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/bridge/placeholderapi/PlaceholderAPIPlaceholder.java b/eternalcore-core/src/main/java/com/eternalcode/core/bridge/placeholderapi/PlaceholderAPIPlaceholder.java index 5e8ffad77..8eea3090d 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/bridge/placeholderapi/PlaceholderAPIPlaceholder.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/bridge/placeholderapi/PlaceholderAPIPlaceholder.java @@ -1,7 +1,6 @@ package com.eternalcode.core.bridge.placeholderapi; -import com.eternalcode.core.placeholder.Placeholder; import me.clip.placeholderapi.PlaceholderAPI; import org.bukkit.entity.Player; diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/afk/placeholder/AfkPlaceholderSetup.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/afk/placeholder/AfkPlaceholderSetup.java index 6a3215a83..cdc29320f 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/afk/placeholder/AfkPlaceholderSetup.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/afk/placeholder/AfkPlaceholderSetup.java @@ -8,7 +8,6 @@ import com.eternalcode.core.injector.annotations.Inject; import com.eternalcode.core.injector.annotations.component.Controller; import com.eternalcode.core.placeholder.PlaceholderRegistry; -import com.eternalcode.core.placeholder.Placeholder; import com.eternalcode.core.publish.Subscribe; import com.eternalcode.core.publish.event.EternalInitializeEvent; import com.eternalcode.core.translation.Translation; diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/home/HomePlaceholderSetup.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/home/HomePlaceholderSetup.java index 86f302c84..4f20ef28c 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/home/HomePlaceholderSetup.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/home/HomePlaceholderSetup.java @@ -5,7 +5,6 @@ import com.eternalcode.core.injector.annotations.Inject; import com.eternalcode.core.injector.annotations.component.Controller; import com.eternalcode.core.placeholder.PlaceholderRegistry; -import com.eternalcode.core.placeholder.Placeholder; import com.eternalcode.core.publish.Subscribe; import com.eternalcode.core.publish.event.EternalInitializeEvent; import com.eternalcode.core.translation.Translation; diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java index f3531871a..161c52b45 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/msg/MsgPlaceholderSetup.java @@ -5,7 +5,7 @@ import com.eternalcode.core.injector.annotations.Inject; import com.eternalcode.core.injector.annotations.component.Controller; import com.eternalcode.core.placeholder.PlaceholderRegistry; -import com.eternalcode.core.placeholder.PlaceholderReplacer; +import com.eternalcode.core.placeholder.Placeholder; import com.eternalcode.core.placeholder.watcher.PlaceholderWatcherKey; import com.eternalcode.core.publish.Subscribe; import com.eternalcode.core.publish.event.EternalInitializeEvent; @@ -37,12 +37,12 @@ public class MsgPlaceholderSetup { void setUpPlaceholders(PlaceholderRegistry registry) { Translation translation = this.translationManager.getMessages(); - registry.registerPlaceholder(PlaceholderReplacer.of( + registry.registerPlaceholder(Placeholder.of( "socialspy_status", player -> String.valueOf(this.msgService.isSpy(player.getUniqueId())) )); - registry.registerPlaceholder(PlaceholderReplacer.of( + registry.registerPlaceholder(Placeholder.of( "socialspy_status_formatted", player -> { UUID uuid = player.getUniqueId(); @@ -52,14 +52,14 @@ void setUpPlaceholders(PlaceholderRegistry registry) { } )); - registry.registerPlaceholder(PlaceholderReplacer.async( + registry.registerPlaceholder(Placeholder.async( "msg_status", MSG_STATE, player -> msgToggleRepository.getPrivateChatState(player), state -> state.name().toLowerCase() )); - registry.registerPlaceholder(PlaceholderReplacer.async( + registry.registerPlaceholder(Placeholder.async( "msg_status_formatted", MSG_STATE, player -> msgToggleRepository.getPrivateChatState(player), diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/NamedPlaceholder.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/NamedPlaceholder.java index b0676dc73..6df52bac1 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/NamedPlaceholder.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/NamedPlaceholder.java @@ -2,7 +2,7 @@ import org.bukkit.entity.Player; -public interface NamedPlaceholder extends PlaceholderReplacer { +public interface NamedPlaceholder extends Placeholder { @Override default String apply(String text, Player targetPlayer) { diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/Placeholder.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/Placeholder.java index 84a12928d..644e5d2f3 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/Placeholder.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/Placeholder.java @@ -1,5 +1,8 @@ package com.eternalcode.core.placeholder; +import com.eternalcode.core.placeholder.watcher.PlaceholderWatcherKey; +import java.util.UUID; +import java.util.concurrent.CompletableFuture; import org.bukkit.entity.Player; import java.util.function.Function; @@ -9,27 +12,36 @@ public interface Placeholder { String apply(String text, Player targetPlayer); static Placeholder of(String target, String replacement) { - return new PlaceholderRaw(target, player -> replacement); + return new StaticValuePlaceholder(target, player -> replacement); } static Placeholder of(String target, Function replacement) { - return new PlaceholderRaw(target, replacement); + return new StaticValuePlaceholder(target, replacement); } static Placeholder ofInt(String target, Function replacement) { - return new PlaceholderRaw(target, player -> String.valueOf(replacement.apply(player))); + return new StaticValuePlaceholder(target, player -> String.valueOf(replacement.apply(player))); } static Placeholder ofBoolean(String target, Function replacement) { - return new PlaceholderRaw(target, player -> String.valueOf(replacement.apply(player))); + return new StaticValuePlaceholder(target, player -> String.valueOf(replacement.apply(player))); } static Placeholder ofLong(String target, Function replacement) { - return new PlaceholderRaw(target, player -> String.valueOf(replacement.apply(player))); + return new StaticValuePlaceholder(target, player -> String.valueOf(replacement.apply(player))); } static Placeholder of(String target, Placeholder placeholder) { - return new PlaceholderRaw(target, player -> placeholder.apply(target, player)); + return new StaticValuePlaceholder(target, player -> placeholder.apply(target, player)); + } + + static Placeholder async( + String target, + PlaceholderWatcherKey key, + Function> loading, + Function mapper + ) { + return new PlaceholderAsync<>(target, key, loading, mapper); } } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderBukkitRegistryImpl.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderBukkitRegistryImpl.java index a298f44aa..9a6193b83 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderBukkitRegistryImpl.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderBukkitRegistryImpl.java @@ -28,8 +28,8 @@ public PlaceholderBukkitRegistryImpl(Server server) { } @Override - public void register(Placeholder stack) { - this.placeholders.add(stack); + public void register(Placeholder placeholder) { + this.placeholders.add(placeholder); if (placeholder instanceof NamedPlaceholder namedPlaceholder) { this.namedPlaceholders.put(namedPlaceholder.getName(), namedPlaceholder); diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderReplacer.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderReplacer.java deleted file mode 100644 index 10e700c88..000000000 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderReplacer.java +++ /dev/null @@ -1,35 +0,0 @@ -package com.eternalcode.core.placeholder; - -import com.eternalcode.core.placeholder.watcher.PlaceholderWatcherKey; -import java.util.UUID; -import java.util.concurrent.CompletableFuture; -import org.bukkit.entity.Player; - -import java.util.function.Function; - -public interface PlaceholderReplacer { - - String apply(String text, Player targetPlayer); - - static PlaceholderReplacer of(String target, String replacement) { - return new PlaceholderRaw(target, player -> replacement); - } - - static PlaceholderReplacer of(String target, Function replacement) { - return new PlaceholderRaw(target, replacement); - } - - static PlaceholderReplacer of(String target, PlaceholderReplacer placeholder) { - return new PlaceholderRaw(target, player -> placeholder.apply(target, player)); - } - - static PlaceholderReplacer async( - String target, - PlaceholderWatcherKey key, - Function> loading, - Function mapper - ) { - return new PlaceholderAsync<>(target, key, loading, mapper); - } - -} diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderRaw.java b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/StaticValuePlaceholder.java similarity index 82% rename from eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderRaw.java rename to eternalcore-core/src/main/java/com/eternalcode/core/placeholder/StaticValuePlaceholder.java index b98950942..114cc9d7e 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/PlaceholderRaw.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/placeholder/StaticValuePlaceholder.java @@ -4,12 +4,12 @@ import java.util.function.Function; -class PlaceholderRaw implements NamedPlaceholder { +class StaticValuePlaceholder implements NamedPlaceholder { private final String name; private final Function replacement; - PlaceholderRaw(String name, Function replacement) { + StaticValuePlaceholder(String name, Function replacement) { this.name = name; this.replacement = replacement; }