feat: timer state

Author: devnatan

inventory-framework-api/src/main/java/me/devnatan/inventoryframework/ViewConfigBuilder.java

@@ -8,6 +8,7 @@
 import java.util.Set;
 import java.util.stream.Collectors;
 import me.devnatan.inventoryframework.exception.InvalidLayoutException;
+import me.devnatan.inventoryframework.state.TimerState;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
@@ -31,6 +32,7 @@ public final class ViewConfigBuilder {
     private String[] layout = null;
     private final Set<ViewConfig.Modifier> modifiers = new HashSet<>();
     private long updateIntervalInTicks, interactionDelayInMillis;
+    private TimerState updateIntervalState;
     private boolean transitiveInitialData;
 
     /**
@@ -200,6 +202,19 @@ public ViewConfigBuilder scheduleUpdate(long intervalInTicks) {
         return this;
     }
 
+    /**
+     * Schedules the view to update every fixed interval.
+     *
+     * @param timerState The
+     * @return This configuration builder.
+     * @see <a href="https://github.com/DevNatan/inventory-framework/wiki/scheduled-updates">Scheduled Updates on Wiki</a>
+     */
+    @ApiStatus.Experimental
+    public ViewConfigBuilder scheduleUpdate(TimerState timerState) {
+        this.updateIntervalState = timerState;
+        return this;
+    }
+
     /**
      * Waits a fixed delay before any player interaction.
      * <p>

inventory-framework-api/src/main/java/me/devnatan/inventoryframework/internal/ElementFactory.java

@@ -17,6 +17,7 @@
 import me.devnatan.inventoryframework.context.IFSlotClickContext;
 import me.devnatan.inventoryframework.context.IFSlotRenderContext;
 import me.devnatan.inventoryframework.logging.Logger;
+import me.devnatan.inventoryframework.state.TimerState;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -88,4 +89,6 @@ public abstract IFSlotRenderContext createSlotRenderContext(
     public abstract boolean worksInCurrentPlatform();
 
     public abstract Job scheduleJobInterval(@NotNull RootView root, long intervalInTicks, @NotNull Runnable execution);
+
+    public abstract TimerState createTimerState(long stateId, long intervalInTicks);
 }

inventory-framework-api/src/main/java/me/devnatan/inventoryframework/state/StateAccess.java

@@ -173,6 +173,19 @@ public interface StateAccess<
      */
     <T> MutableState<T> initialState(@NotNull String key);
 
+    /**
+     * Creates a new unmodifiable timer state.
+     *
+     * @param intervalInTicks Ticks to schedule the timer to run.
+     * <p>
+     * <b><i> This API is experimental and is not subject to the general compatibility guarantees
+     * such API may be changed or may be removed completely in any further release. </i></b>
+     *
+     * @return A new unmodifiable timer state.
+     */
+    @ApiStatus.Experimental
+    TimerState timerState(long intervalInTicks);
+
     /**
      * Creates a new immutable pagination with static data source.
      *

inventory-framework-api/src/main/java/me/devnatan/inventoryframework/state/TimerState.java

@@ -0,0 +1,6 @@
+package me.devnatan.inventoryframework.state;
+
+public interface TimerState extends State<TimerState.Timer> {
+
+    interface Timer {}
+}

inventory-framework-core/src/main/java/me/devnatan/inventoryframework/state/StateAccessImpl.java

@@ -38,7 +38,7 @@ public StateAccessImpl(Object caller, ElementFactory elementFactory, StateRegist
     }
 
     @Override
-    public final <T> State<T> state(T initialValue) {
+    public <T> State<T> state(T initialValue) {
         final long id = State.next();
         final StateValueFactory factory = (host, state) -> new ImmutableValue(state, initialValue);
         final State<T> state = new BaseState<>(id, factory);
@@ -48,7 +48,7 @@ public final <T> State<T> state(T initialValue) {
     }
 
     @Override
-    public final <T> MutableState<T> mutableState(T initialValue) {
+    public <T> MutableState<T> mutableState(T initialValue) {
         final long id = State.next();
         final StateValueFactory factory = (host, state) -> new MutableValue(state, initialValue);
         final MutableState<T> state = new MutableGenericStateImpl<>(id, factory);
@@ -58,7 +58,7 @@ public final <T> MutableState<T> mutableState(T initialValue) {
     }
 
     @Override
-    public final MutableIntState mutableState(int initialValue) {
+    public MutableIntState mutableState(int initialValue) {
         final long id = State.next();
         final StateValueFactory factory = (host, state) -> new MutableValue(state, initialValue);
         final MutableIntState state = new MutableIntStateImpl(id, factory);
@@ -68,7 +68,7 @@ public final MutableIntState mutableState(int initialValue) {
     }
 
     @Override
-    public final <T> State<T> computedState(@NotNull Function<Context, T> computation) {
+    public <T> State<T> computedState(@NotNull Function<Context, T> computation) {
         final long id = State.next();
         @SuppressWarnings("unchecked")
         final StateValueFactory factory =
@@ -80,7 +80,7 @@ public final <T> State<T> computedState(@NotNull Function<Context, T> computatio
     }
 
     @Override
-    public final <T> State<T> computedState(@NotNull Supplier<T> computation) {
+    public <T> State<T> computedState(@NotNull Supplier<T> computation) {
         final long id = State.next();
         final StateValueFactory factory = (host, state) -> new ComputedValue(state, computation);
         final State<T> state = new BaseState<>(id, factory);
@@ -90,7 +90,7 @@ public final <T> State<T> computedState(@NotNull Supplier<T> computation) {
     }
 
     @Override
-    public final <T> State<T> lazyState(@NotNull Function<Context, T> computation) {
+    public <T> State<T> lazyState(@NotNull Function<Context, T> computation) {
         final long id = State.next();
         @SuppressWarnings("unchecked")
         final StateValueFactory factory =
@@ -102,7 +102,7 @@ public final <T> State<T> lazyState(@NotNull Function<Context, T> computation) {
     }
 
     @Override
-    public final <T> State<T> lazyState(@NotNull Supplier<T> computation) {
+    public <T> State<T> lazyState(@NotNull Supplier<T> computation) {
         final long id = State.next();
         final StateValueFactory factory = (host, state) -> new LazyValue(state, computation);
         final State<T> state = new BaseState<>(id, factory);
@@ -113,13 +113,13 @@ public final <T> State<T> lazyState(@NotNull Supplier<T> computation) {
 
     @SuppressWarnings("DataFlowIssue")
     @Override
-    public final <T> MutableState<T> initialState() {
+    public <T> MutableState<T> initialState() {
         return initialState(null);
     }
 
     @SuppressWarnings("NullableProblems")
     @Override
-    public final <T> MutableState<T> initialState(@NotNull String key) {
+    public <T> MutableState<T> initialState(@NotNull String key) {
         final long id = State.next();
         final MutableState<T> state =
                 new BaseMutableState<>(id, (host, valueState) -> new InitialDataStateValue(valueState, host, key));
@@ -129,7 +129,14 @@ public final <T> MutableState<T> initialState(@NotNull String key) {
     }
 
     @Override
-    public final <T> State<Pagination> paginationState(
+    public TimerState timerState(long intervalInTicks) {
+        final TimerState state = elementFactory.createTimerState(State.next(), intervalInTicks);
+        this.stateRegistry.registerState(state, this);
+        return state;
+    }
+
+    @Override
+    public <T> State<Pagination> paginationState(
             @NotNull List<? super T> sourceProvider,
             @NotNull PaginationValueConsumer<Context, ItemBuilder, T> elementConsumer) {
         return this.<T>buildPaginationState(sourceProvider)
@@ -138,7 +145,7 @@ public final <T> State<Pagination> paginationState(
     }
 
     @Override
-    public final <T> State<Pagination> computedPaginationState(
+    public <T> State<Pagination> computedPaginationState(
             @NotNull Function<Context, List<? super T>> sourceProvider,
             @NotNull PaginationValueConsumer<Context, ItemBuilder, T> valueConsumer) {
         return this.buildComputedPaginationState(sourceProvider)
@@ -147,7 +154,7 @@ public final <T> State<Pagination> computedPaginationState(
     }
 
     @Override
-    public final <T> State<Pagination> computedAsyncPaginationState(
+    public <T> State<Pagination> computedAsyncPaginationState(
             @NotNull Function<Context, CompletableFuture<List<T>>> sourceProvider,
             @NotNull PaginationValueConsumer<Context, ItemBuilder, T> valueConsumer) {
         return this.buildComputedAsyncPaginationState(sourceProvider)
@@ -156,7 +163,7 @@ public final <T> State<Pagination> computedAsyncPaginationState(
     }
 
     @Override
-    public final <T> State<Pagination> lazyPaginationState(
+    public <T> State<Pagination> lazyPaginationState(
             @NotNull Function<Context, List<? super T>> sourceProvider,
             @NotNull PaginationValueConsumer<Context, ItemBuilder, T> valueConsumer) {
         return this.buildLazyPaginationState(sourceProvider)
@@ -183,48 +190,48 @@ public <T> State<Pagination> lazyAsyncPaginationState(
     }
 
     @Override
-    public final <T> PaginationStateBuilder<Context, ItemBuilder, T> buildPaginationState(
+    public <T> PaginationStateBuilder<Context, ItemBuilder, T> buildPaginationState(
             @NotNull List<? super T> sourceProvider) {
         return new PaginationStateBuilder<>(
                 this.elementFactory, sourceProvider, this::createPaginationState, false, false);
     }
 
     @Override
-    public final <T> PaginationStateBuilder<Context, ItemBuilder, T> buildComputedPaginationState(
+    public <T> PaginationStateBuilder<Context, ItemBuilder, T> buildComputedPaginationState(
             @NotNull Function<Context, List<? super T>> sourceProvider) {
         return new PaginationStateBuilder<>(
                 this.elementFactory, sourceProvider, this::createPaginationState, false, true);
     }
 
     @Override
-    public final <T> PaginationStateBuilder<Context, ItemBuilder, T> buildComputedAsyncPaginationState(
+    public <T> PaginationStateBuilder<Context, ItemBuilder, T> buildComputedAsyncPaginationState(
             @NotNull Function<Context, CompletableFuture<List<T>>> sourceProvider) {
         return new PaginationStateBuilder<>(
                 this.elementFactory, sourceProvider, this::createPaginationState, true, true);
     }
 
     @Override
-    public final <T> PaginationStateBuilder<Context, ItemBuilder, T> buildLazyPaginationState(
+    public <T> PaginationStateBuilder<Context, ItemBuilder, T> buildLazyPaginationState(
             @NotNull Supplier<List<? super T>> sourceProvider) {
         return new PaginationStateBuilder<>(
                 this.elementFactory, sourceProvider, this::createPaginationState, false, false);
     }
 
     @Override
-    public final <T> PaginationStateBuilder<Context, ItemBuilder, T> buildLazyPaginationState(
+    public <T> PaginationStateBuilder<Context, ItemBuilder, T> buildLazyPaginationState(
             @NotNull Function<Context, List<? super T>> sourceProvider) {
         return new PaginationStateBuilder<>(
                 this.elementFactory, sourceProvider, this::createPaginationState, false, false);
     }
 
     @Override
-    public final <T> PaginationStateBuilder<Context, ItemBuilder, T> buildLazyAsyncPaginationState(
+    public <T> PaginationStateBuilder<Context, ItemBuilder, T> buildLazyAsyncPaginationState(
             @NotNull Function<Context, CompletableFuture<List<T>>> sourceProvider) {
         return new PaginationStateBuilder<>(
                 this.elementFactory, sourceProvider, this::createPaginationState, true, false);
     }
 
-    protected final <V> State<Pagination> createPaginationState(
+    private <V> State<Pagination> createPaginationState(
             @NotNull PaginationStateBuilder<Context, ItemBuilder, V> builder) {
         final long id = State.next();
         @SuppressWarnings({"unchecked", "rawtypes"})