Make Item.Builder function naming consistent with the rest of InvUI

NichtStudioCode · NichtStudioCode · commit 313572fd7cb1 · 2024-12-03T13:03:04.000+01:00
diff --git a/invui-kotlin/src/main/kotlin/xyz/xenondevs/invui/item/ReactiveItems.kt b/invui-kotlin/src/main/kotlin/xyz/xenondevs/invui/item/ReactiveItems.kt
@@ -16,8 +16,8 @@ import kotlin.experimental.ExperimentalTypeInference
 private fun <S : Item.Builder<*>> S.reactiveItemProvider(
     itemProviderProvider: Provider<ItemProvider>
 ): S {
-    modify { item -> itemProviderProvider.observe { item.notifyWindows() } }
-    return itemProvider(itemProviderProvider) as S
+    addModifier { item -> itemProviderProvider.observeWeak(item) { weakItem -> weakItem.notifyWindows() } }
+    return setItemProvider(itemProviderProvider) as S
 }
 
 @OverloadResolutionByLambdaReturnType
@@ -136,7 +136,7 @@ fun <S : Item.Builder<*>, A, B, C, D, E, F, G, H, I, J> S.itemProvider(
 ): S = reactiveItemProvider(combinedProvider(a, b, c, d, e, f, g, h, i, j, mapValue))
 
 private fun <S : Item.Builder<*>> S.observeAndNotify(vararg providers: Provider<*>) {
-    providers.forEach { provider -> modify { item -> provider.observe { item.notifyWindows() } } }
+    providers.forEach { provider -> addModifier { item -> provider.observeWeak(item) { weakItem -> weakItem.notifyWindows() } } }
 }
 
 @OverloadResolutionByLambdaReturnType
@@ -147,7 +147,7 @@ fun <S : Item.Builder<*>, A> S.itemProvider(
     mapValue: (Player, A) -> ItemProvider
 ): S {
     observeAndNotify(a)
-    return itemProvider { player: Player -> mapValue(player, a.get()) } as S
+    return setItemProvider { player: Player -> mapValue(player, a.get()) } as S
 }
 
 @OverloadResolutionByLambdaReturnType
@@ -159,7 +159,7 @@ fun <S : Item.Builder<*>, A, B> S.itemProvider(
     mapValue: (Player, A, B) -> ItemProvider
 ): S {
     observeAndNotify(a, b)
-    return itemProvider { player: Player -> mapValue(player, a.get(), b.get()) } as S
+    return setItemProvider { player: Player -> mapValue(player, a.get(), b.get()) } as S
 }
 
 @OverloadResolutionByLambdaReturnType
@@ -172,7 +172,7 @@ fun <S : Item.Builder<*>, A, B, C> S.itemProvider(
     mapValue: (Player, A, B, C) -> ItemProvider
 ): S {
     observeAndNotify(a, b, c)
-    return itemProvider { player: Player -> mapValue(player, a.get(), b.get(), c.get()) } as S
+    return setItemProvider { player: Player -> mapValue(player, a.get(), b.get(), c.get()) } as S
 }
 
 @OverloadResolutionByLambdaReturnType
@@ -186,7 +186,7 @@ fun <S : Item.Builder<*>, A, B, C, D> S.itemProvider(
     mapValue: (Player, A, B, C, D) -> ItemProvider
 ): S {
     observeAndNotify(a, b, c, d)
-    return itemProvider { player: Player -> mapValue(player, a.get(), b.get(), c.get(), d.get()) } as S
+    return setItemProvider { player: Player -> mapValue(player, a.get(), b.get(), c.get(), d.get()) } as S
 }
 
 @OverloadResolutionByLambdaReturnType
@@ -201,7 +201,7 @@ fun <S : Item.Builder<*>, A, B, C, D, E> S.itemProvider(
     mapValue: (Player, A, B, C, D, E) -> ItemProvider
 ): S {
     observeAndNotify(a, b, c, d, e)
-    return itemProvider { player: Player -> mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get()) } as S
+    return setItemProvider { player: Player -> mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get()) } as S
 }
 
 @OverloadResolutionByLambdaReturnType
@@ -217,7 +217,7 @@ fun <S : Item.Builder<*>, A, B, C, D, E, F> S.itemProvider(
     mapValue: (Player, A, B, C, D, E, F) -> ItemProvider
 ): S {
     observeAndNotify(a, b, c, d, e, f)
-    return itemProvider { player: Player -> mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get(), f.get()) } as S
+    return setItemProvider { player: Player -> mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get(), f.get()) } as S
 }
 
 @OverloadResolutionByLambdaReturnType
@@ -234,7 +234,7 @@ fun <S : Item.Builder<*>, A, B, C, D, E, F, G, H, I, J> S.itemProvider(
     mapValue: (Player, A, B, C, D, E, F, G) -> ItemProvider
 ): S {
     observeAndNotify(a, b, c, d, e, f, g)
-    return itemProvider { player: Player -> mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get(), f.get(), g.get()) } as S
+    return setItemProvider { player: Player -> mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get(), f.get(), g.get()) } as S
 }
 
 @OverloadResolutionByLambdaReturnType
@@ -252,7 +252,7 @@ fun <S : Item.Builder<*>, A, B, C, D, E, F, G, H> S.itemProvider(
     mapValue: (Player, A, B, C, D, E, F, G, H) -> ItemProvider
 ): S {
     observeAndNotify(a, b, c, d, e, f, g, h)
-    return itemProvider { player: Player -> mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get(), f.get(), g.get(), h.get()) } as S
+    return setItemProvider { player: Player -> mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get(), f.get(), g.get(), h.get()) } as S
 }
 
 @OverloadResolutionByLambdaReturnType
@@ -271,7 +271,7 @@ fun <S : Item.Builder<*>, A, B, C, D, E, F, G, H, I> S.itemProvider(
     mapValue: (Player, A, B, C, D, E, F, G, H, I) -> ItemProvider
 ): S {
     observeAndNotify(a, b, c, d, e, f, g, h, i)
-    return itemProvider { player: Player -> mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get(), f.get(), g.get(), h.get(), i.get()) } as S
+    return setItemProvider { player: Player -> mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get(), f.get(), g.get(), h.get(), i.get()) } as S
 }
 
 @OverloadResolutionByLambdaReturnType
@@ -291,7 +291,7 @@ fun <S : Item.Builder<*>, A, B, C, D, E, F, G, H, I, J> S.itemProvider(
     mapValue: (Player, A, B, C, D, E, F, G, H, I, J) -> ItemProvider
 ): S {
     observeAndNotify(a, b, c, d, e, f, g, h, i, j)
-    return itemProvider { player: Player -> mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get(), f.get(), g.get(), h.get(), i.get(), j.get()) } as S
+    return setItemProvider { player: Player -> mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get(), f.get(), g.get(), h.get(), i.get(), j.get()) } as S
 }
 
 @OverloadResolutionByLambdaReturnType
@@ -434,7 +434,7 @@ fun <S : Item.Builder<*>, A> S.itemProvider(
     mapValue: (Player, A) -> ItemStack
 ): S {
     observeAndNotify(a)
-    return itemProvider { player: Player -> ItemWrapper(mapValue(player, a.get())) } as S
+    return setItemProvider { player: Player -> ItemWrapper(mapValue(player, a.get())) } as S
 }
 
 @OverloadResolutionByLambdaReturnType
@@ -446,7 +446,7 @@ fun <S : Item.Builder<*>, A, B> S.itemProvider(
     mapValue: (Player, A, B) -> ItemStack
 ): S {
     observeAndNotify(a, b)
-    return itemProvider { player: Player -> ItemWrapper(mapValue(player, a.get(), b.get())) } as S
+    return setItemProvider { player: Player -> ItemWrapper(mapValue(player, a.get(), b.get())) } as S
 }
 
 @OverloadResolutionByLambdaReturnType
@@ -459,7 +459,7 @@ fun <S : Item.Builder<*>, A, B, C> S.itemProvider(
     mapValue: (Player, A, B, C) -> ItemStack
 ): S {
     observeAndNotify(a, b, c)
-    return itemProvider { player: Player -> ItemWrapper(mapValue(player, a.get(), b.get(), c.get())) } as S
+    return setItemProvider { player: Player -> ItemWrapper(mapValue(player, a.get(), b.get(), c.get())) } as S
 }
 
 @OverloadResolutionByLambdaReturnType
@@ -473,7 +473,7 @@ fun <S : Item.Builder<*>, A, B, C, D> S.itemProvider(
     mapValue: (Player, A, B, C, D) -> ItemStack
 ): S {
     observeAndNotify(a, b, c, d)
-    return itemProvider { player: Player -> ItemWrapper(mapValue(player, a.get(), b.get(), c.get(), d.get())) } as S
+    return setItemProvider { player: Player -> ItemWrapper(mapValue(player, a.get(), b.get(), c.get(), d.get())) } as S
 }
 
 @OverloadResolutionByLambdaReturnType
@@ -488,7 +488,7 @@ fun <S : Item.Builder<*>, A, B, C, D, E> S.itemProvider(
     mapValue: (Player, A, B, C, D, E) -> ItemStack
 ): S {
     observeAndNotify(a, b, c, d, e)
-    return itemProvider { player: Player -> ItemWrapper(mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get())) } as S
+    return setItemProvider { player: Player -> ItemWrapper(mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get())) } as S
 }
 
 @OverloadResolutionByLambdaReturnType
@@ -504,7 +504,7 @@ fun <S : Item.Builder<*>, A, B, C, D, E, F> S.itemProvider(
     mapValue: (Player, A, B, C, D, E, F) -> ItemStack
 ): S {
     observeAndNotify(a, b, c, d, e, f)
-    return itemProvider { player: Player -> ItemWrapper(mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get(), f.get())) } as S
+    return setItemProvider { player: Player -> ItemWrapper(mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get(), f.get())) } as S
 }
 
 @OverloadResolutionByLambdaReturnType
@@ -521,7 +521,7 @@ fun <S : Item.Builder<*>, A, B, C, D, E, F, G, H, I, J> S.itemProvider(
     mapValue: (Player, A, B, C, D, E, F, G) -> ItemStack
 ): S {
     observeAndNotify(a, b, c, d, e, f, g)
-    return itemProvider { player: Player -> ItemWrapper(mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get(), f.get(), g.get())) } as S
+    return setItemProvider { player: Player -> ItemWrapper(mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get(), f.get(), g.get())) } as S
 }
 
 @OverloadResolutionByLambdaReturnType
@@ -539,7 +539,7 @@ fun <S : Item.Builder<*>, A, B, C, D, E, F, G, H> S.itemProvider(
     mapValue: (Player, A, B, C, D, E, F, G, H) -> ItemStack
 ): S {
     observeAndNotify(a, b, c, d, e, f, g, h)
-    return itemProvider { player: Player -> ItemWrapper(mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get(), f.get(), g.get(), h.get())) } as S
+    return setItemProvider { player: Player -> ItemWrapper(mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get(), f.get(), g.get(), h.get())) } as S
 }
 
 @OverloadResolutionByLambdaReturnType
@@ -558,7 +558,7 @@ fun <S : Item.Builder<*>, A, B, C, D, E, F, G, H, I> S.itemProvider(
     mapValue: (Player, A, B, C, D, E, F, G, H, I) -> ItemStack
 ): S {
     observeAndNotify(a, b, c, d, e, f, g, h, i)
-    return itemProvider { player: Player -> ItemWrapper(mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get(), f.get(), g.get(), h.get(), i.get())) } as S
+    return setItemProvider { player: Player -> ItemWrapper(mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get(), f.get(), g.get(), h.get(), i.get())) } as S
 }
 
 @OverloadResolutionByLambdaReturnType
@@ -578,5 +578,5 @@ fun <S : Item.Builder<*>, A, B, C, D, E, F, G, H, I, J> S.itemProvider(
     mapValue: (Player, A, B, C, D, E, F, G, H, I, J) -> ItemStack
 ): S {
     observeAndNotify(a, b, c, d, e, f, g, h, i, j)
-    return itemProvider { player: Player -> ItemWrapper(mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get(), f.get(), g.get(), h.get(), i.get(), j.get())) } as S
+    return setItemProvider { player: Player -> ItemWrapper(mapValue(player, a.get(), b.get(), c.get(), d.get(), e.get(), f.get(), g.get(), h.get(), i.get(), j.get())) } as S
 }
diff --git a/invui/src/main/java/xyz/xenondevs/invui/item/BoundItem.java b/invui/src/main/java/xyz/xenondevs/invui/item/BoundItem.java
@@ -50,11 +50,11 @@ static Builder<TabGui<?>> tabGui() {
     
     sealed interface Builder<G extends Gui> extends Item.Builder<Builder<G>> permits CustomBoundItem.Builder {
 
-        Builder<G> bind(BiConsumer<Item, G> handler);
+        Builder<G> addBindHandler(BiConsumer<Item, G> handler);
         
-        Builder<G> click(TriConsumer<Item, G, Click> handler);
+        Builder<G> addClickHandler(TriConsumer<Item, G, Click> handler);
         
-        Builder<G> itemProvider(BiFunction<Player, G, ItemProvider> itemProvider);
+        Builder<G> setItemProvider(BiFunction<Player, G, ItemProvider> itemProvider);
         
     }
     
diff --git a/invui/src/main/java/xyz/xenondevs/invui/item/CustomBoundItem.java b/invui/src/main/java/xyz/xenondevs/invui/item/CustomBoundItem.java
@@ -88,25 +88,25 @@ non-sealed static class Builder<G extends Gui> implements BoundItem.Builder<G> {
         private long updatePeriod = -1L;
         
         @Override
-        public Builder<G> itemProvider(ItemProvider itemProvider) {
+        public Builder<G> setItemProvider(ItemProvider itemProvider) {
             this.itemProviderFn = (viewer, gui) -> itemProvider;
             return this;
         }
         
         @Override
-        public Builder<G> itemProvider(Supplier<ItemProvider> itemProvider) {
+        public Builder<G> setItemProvider(Supplier<ItemProvider> itemProvider) {
             this.itemProviderFn = (viewer, gui) -> itemProvider.get();
             return this;
         }
         
         @Override
-        public Builder<G> itemProvider(Function<Player, ItemProvider> itemProvider) {
+        public Builder<G> setItemProvider(Function<Player, ItemProvider> itemProvider) {
             this.itemProviderFn = (viewer, gui) -> itemProvider.apply(viewer);
             return this;
         }
         
         @Override
-        public Builder<G> itemProvider(BiFunction<Player, G, ItemProvider> itemProvider) {
+        public Builder<G> setItemProvider(BiFunction<Player, G, ItemProvider> itemProvider) {
             this.itemProviderFn = itemProvider;
             return this;
         }
@@ -130,25 +130,25 @@ public Builder<G> updateOnClick() {
         }
         
         @Override
-        public Builder<G> click(BiConsumer<Item, Click> clickHandler) {
+        public Builder<G> addClickHandler(BiConsumer<Item, Click> clickHandler) {
             this.clickHandler.andThen((item, gui, click) -> clickHandler.accept(item, click));
             return this;
         }
         
         @Override
-        public Builder<G> click(TriConsumer<Item, G, Click> handler) {
+        public Builder<G> addClickHandler(TriConsumer<Item, G, Click> handler) {
             clickHandler = clickHandler.andThen(handler);
             return this;
         }
         
         @Override
-        public Builder<G> bind(BiConsumer<Item, G> handler) {
+        public Builder<G> addBindHandler(BiConsumer<Item, G> handler) {
             bindHandler = bindHandler.andThen(handler);
             return this;
         }
         
         @Override
-        public Builder<G> modify(Consumer<Item> modifier) {
+        public Builder<G> addModifier(Consumer<Item> modifier) {
             this.modifier = this.modifier.andThen(modifier);
             return this;
         }
diff --git a/invui/src/main/java/xyz/xenondevs/invui/item/CustomItem.java b/invui/src/main/java/xyz/xenondevs/invui/item/CustomItem.java
@@ -68,19 +68,19 @@ static final class Builder implements Item.Builder<Builder> {
         private long updatePeriod = -1L;
         
         @Override
-        public Builder itemProvider(ItemProvider itemProvider) {
+        public Builder setItemProvider(ItemProvider itemProvider) {
             this.itemProviderFn = viewer -> itemProvider;
             return this;
         }
         
         @Override
-        public Builder itemProvider(Supplier<ItemProvider> itemProvider) {
+        public Builder setItemProvider(Supplier<ItemProvider> itemProvider) {
             this.itemProviderFn = viewer -> itemProvider.get();
             return this;
         }
         
         @Override
-        public Builder itemProvider(Function<Player, ItemProvider> itemProvider) {
+        public Builder setItemProvider(Function<Player, ItemProvider> itemProvider) {
             this.itemProviderFn = itemProvider;
             return this;
         }
@@ -104,13 +104,13 @@ public Builder updateOnClick() {
         }
         
         @Override
-        public Builder click(BiConsumer<Item, Click> clickHandler) {
+        public Builder addClickHandler(BiConsumer<Item, Click> clickHandler) {
             this.clickHandler = clickHandler;
             return this;
         }
         
         @Override
-        public Builder modify(Consumer<Item> modifier) {
+        public Builder addModifier(Consumer<Item> modifier) {
             this.modifier = this.modifier.andThen(modifier);
             return this;
         }
diff --git a/invui/src/main/java/xyz/xenondevs/invui/item/Item.java b/invui/src/main/java/xyz/xenondevs/invui/item/Item.java
@@ -49,38 +49,38 @@ static Builder<?> builder() {
     }
     
     static Item simple(ItemStack itemStack) {
-        return builder().itemProvider(new ItemWrapper(itemStack)).build();
+        return builder().setItemProvider(new ItemWrapper(itemStack)).build();
     }
     
     static Item simple(ItemProvider itemProvider) {
-        return builder().itemProvider(itemProvider).build();
+        return builder().setItemProvider(itemProvider).build();
     }
     
     static Item simple(Supplier<ItemProvider> itemProvider) {
-        return builder().itemProvider(itemProvider).build();
+        return builder().setItemProvider(itemProvider).build();
     }
     
     static Item simple(Function<Player, ItemProvider> itemProvider) {
-        return builder().itemProvider(itemProvider).build();
+        return builder().setItemProvider(itemProvider).build();
     }
     
     interface Builder<S extends Builder<S>> {
         
-        S itemProvider(ItemProvider itemProvider);
+        S setItemProvider(ItemProvider itemProvider);
         
-        S itemProvider(Supplier<ItemProvider> itemProvider);
+        S setItemProvider(Supplier<ItemProvider> itemProvider);
         
-        S itemProvider(Function<Player, ItemProvider> itemProvider);
+        S setItemProvider(Function<Player, ItemProvider> itemProvider);
         
         S async(ItemProvider placeholder);
         
         S updatePeriodically(long period);
         
         S updateOnClick();
         
-        S click(BiConsumer<Item, Click> clickHandler);
+        S addClickHandler(BiConsumer<Item, Click> clickHandler);
         
-        S modify(Consumer<Item> modifier);
+        S addModifier(Consumer<Item> modifier);
         
         Item build();
         

Original file line number	Diff line number	Diff line change
`@@ -50,11 +50,11 @@ static Builder<TabGui<?>> tabGui() {`
`50`	`50`
`51`	`51`	`sealed interface Builder<G extends Gui> extends Item.Builder<Builder<G>> permits CustomBoundItem.Builder {`
`52`	`52`
`53`		`- Builder<G> bind(BiConsumer<Item, G> handler);`
	`53`	`+ Builder<G> addBindHandler(BiConsumer<Item, G> handler);`
`54`	`54`
`55`		`- Builder<G> click(TriConsumer<Item, G, Click> handler);`
	`55`	`+ Builder<G> addClickHandler(TriConsumer<Item, G, Click> handler);`
`56`	`56`
`57`		`- Builder<G> itemProvider(BiFunction<Player, G, ItemProvider> itemProvider);`
	`57`	`+ Builder<G> setItemProvider(BiFunction<Player, G, ItemProvider> itemProvider);`
`58`	`58`
`59`	`59`	`}`
`60`	`60`
Original file line number	Diff line number	Diff line change
`@@ -68,19 +68,19 @@ static final class Builder implements Item.Builder<Builder> {`
`68`	`68`	`private long updatePeriod = -1L;`
`69`	`69`
`70`	`70`	`@Override`
`71`		`- public Builder itemProvider(ItemProvider itemProvider) {`
	`71`	`+ public Builder setItemProvider(ItemProvider itemProvider) {`
`72`	`72`	`this.itemProviderFn = viewer -> itemProvider;`
`73`	`73`	`return this;`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`@Override`
`77`		`- public Builder itemProvider(Supplier<ItemProvider> itemProvider) {`
	`77`	`+ public Builder setItemProvider(Supplier<ItemProvider> itemProvider) {`
`78`	`78`	`this.itemProviderFn = viewer -> itemProvider.get();`
`79`	`79`	`return this;`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`@Override`
`83`		`- public Builder itemProvider(Function<Player, ItemProvider> itemProvider) {`
	`83`	`+ public Builder setItemProvider(Function<Player, ItemProvider> itemProvider) {`
`84`	`84`	`this.itemProviderFn = itemProvider;`
`85`	`85`	`return this;`
`86`	`86`	`}`
`@@ -104,13 +104,13 @@ public Builder updateOnClick() {`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`@Override`
`107`		`- public Builder click(BiConsumer<Item, Click> clickHandler) {`
	`107`	`+ public Builder addClickHandler(BiConsumer<Item, Click> clickHandler) {`
`108`	`108`	`this.clickHandler = clickHandler;`
`109`	`109`	`return this;`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`@Override`
`113`		`- public Builder modify(Consumer<Item> modifier) {`
	`113`	`+ public Builder addModifier(Consumer<Item> modifier) {`
`114`	`114`	`this.modifier = this.modifier.andThen(modifier);`
`115`	`115`	`return this;`
`116`	`116`	`}`