SteamWar/Paper
9
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Tag Lifecycle Events

Browse Source 
== AT ==
public net/minecraft/tags/TagEntry id
public net/minecraft/tags/TagEntry tag
public net/minecraft/tags/TagEntry required
This commit is contained in:
Jake Potrebic
2024-06-20 09:40:57 -07:00
parent 45d04f9749
commit 193eebecdf
12 changed files with 510 additions and 8 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
paper-server/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/LifecycleEventTypeProviderImpl.java
View File

@@ -13,6 +13,8 @@ public final class LifecycleEventTypeProviderImpl implements LifecycleEventTypeP
return (LifecycleEventTypeProviderImpl) LifecycleEventTypeProvider.provider();
}
private final PaperTagEventTypeProvider provider = new PaperTagEventTypeProvider();
@Override
public <O extends LifecycleEventOwner, E extends LifecycleEvent> LifecycleEventType.Monitorable<O, E> monitor(final String name, final Class<? extends O> ownerType) {
return new MonitorableLifecycleEventType<>(name, ownerType);
@@ -22,4 +24,9 @@ public final class LifecycleEventTypeProviderImpl implements LifecycleEventTypeP
public <O extends LifecycleEventOwner, E extends LifecycleEvent> LifecycleEventType.Prioritizable<O, E> prioritized(final String name, final Class<? extends O> ownerType) {
return new PrioritizableLifecycleEventType.Simple<>(name, ownerType);
}
@Override
public PaperTagEventTypeProvider tagProvider() {
return this.provider;
}
}

24
paper-server/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/PaperTagEventTypeProvider.java Normal file
View File

@@ -0,0 +1,24 @@
package io.papermc.paper.plugin.lifecycle.event.types;
import io.papermc.paper.plugin.bootstrap.BootstrapContext;
import io.papermc.paper.plugin.lifecycle.event.registrar.ReloadableRegistrarEvent;
import io.papermc.paper.registry.RegistryKey;
import io.papermc.paper.tag.PaperTagListenerManager;
import io.papermc.paper.tag.PostFlattenTagRegistrar;
import io.papermc.paper.tag.PreFlattenTagRegistrar;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.framework.qual.DefaultQualifier;
@DefaultQualifier(NonNull.class)
public class PaperTagEventTypeProvider implements TagEventTypeProvider {
@Override
public <T> PrioritizableLifecycleEventType.Simple<BootstrapContext, ReloadableRegistrarEvent<PreFlattenTagRegistrar<T>>> preFlatten(final RegistryKey<T> registryKey) {
return PaperTagListenerManager.INSTANCE.getPreFlattenType(registryKey);
}
@Override
public <T> PrioritizableLifecycleEventType.Simple<BootstrapContext, ReloadableRegistrarEvent<PostFlattenTagRegistrar<T>>> postFlatten(final RegistryKey<T> registryKey) {
return PaperTagListenerManager.INSTANCE.getPostFlattenType(registryKey);
}
}

119
paper-server/src/main/java/io/papermc/paper/tag/PaperPostFlattenTagRegistrar.java Normal file
View File

@@ -0,0 +1,119 @@
package io.papermc.paper.tag;
import com.google.common.collect.Collections2;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import io.papermc.paper.adventure.PaperAdventure;
import io.papermc.paper.plugin.bootstrap.BootstrapContext;
import io.papermc.paper.plugin.lifecycle.event.registrar.PaperRegistrar;
import io.papermc.paper.registry.RegistryKey;
import io.papermc.paper.registry.TypedKey;
import io.papermc.paper.registry.tag.TagKey;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Optional;
import java.util.function.Function;
import net.minecraft.resources.ResourceLocation;
import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;
import org.checkerframework.framework.qual.DefaultQualifier;
@SuppressWarnings("BoundedWildcard")
@DefaultQualifier(NonNull.class)
public class PaperPostFlattenTagRegistrar<M, T> implements PaperRegistrar<BootstrapContext>, PostFlattenTagRegistrar<T> {
public final Map<ResourceLocation, List<M>> tags;
private final Function<ResourceLocation, Optional<? extends M>> fromIdConverter;
private final Function<M, ResourceLocation> toIdConverter;
private final RegistryKey<T> registryKey;
public PaperPostFlattenTagRegistrar(
final Map<ResourceLocation, List<M>> tags,
final TagEventConfig<M, T> config
) {
this.tags = tags;
this.fromIdConverter = config.fromIdConverter();
this.toIdConverter = config.toIdConverter();
this.registryKey = config.apiRegistryKey();
}
@Override
public void setCurrentContext(final @Nullable BootstrapContext owner) {
}
@Override
public RegistryKey<T> registryKey() {
return this.registryKey;
}
@Override
public Map<TagKey<T>, Collection<TypedKey<T>>> getAllTags() {
final ImmutableMap.Builder<TagKey<T>, Collection<TypedKey<T>>> tags = ImmutableMap.builderWithExpectedSize(this.tags.size());
for (final Map.Entry<ResourceLocation, List<M>> entry : this.tags.entrySet()) {
final TagKey<T> key = TagKey.create(this.registryKey, CraftNamespacedKey.fromMinecraft(entry.getKey()));
tags.put(key, this.convert(entry.getValue()));
}
return tags.build();
}
private List<TypedKey<T>> convert(final List<M> nms) {
return Collections.unmodifiableList(
Lists.transform(nms, m -> this.convert(this.toIdConverter.apply(m)))
);
}
private TypedKey<T> convert(final ResourceLocation location) {
return TypedKey.create(this.registryKey, CraftNamespacedKey.fromMinecraft(location));
}
private M convert(final TypedKey<T> key) {
final Optional<? extends M> optional = this.fromIdConverter.apply(PaperAdventure.asVanilla(key.key()));
if (optional.isEmpty()) {
throw new IllegalArgumentException(key + " doesn't exist");
}
return optional.get();
}
@Override
public boolean hasTag(final TagKey<T> tagKey) {
return this.tags.containsKey(PaperAdventure.asVanilla(tagKey.key()));
}
private List<M> getNmsTag(final TagKey<T> tagKey, final boolean create) {
final ResourceLocation vanillaKey = PaperAdventure.asVanilla(tagKey.key());
List<M> tag = this.tags.get(vanillaKey);
if (tag == null) {
if (create) {
tag = this.tags.computeIfAbsent(vanillaKey, k -> new ArrayList<>());
} else {
throw new NoSuchElementException("Tag " + tagKey + " is not present");
}
}
return tag;
}
@Override
public Collection<TypedKey<T>> getTag(final TagKey<T> tagKey) {
return this.convert(this.getNmsTag(tagKey, false));
}
@Override
public void addToTag(final TagKey<T> tagKey, final Collection<TypedKey<T>> values) {
final List<M> nmsTag = new ArrayList<>(this.getNmsTag(tagKey, true));
for (final TypedKey<T> key : values) {
nmsTag.add(this.convert(key));
}
this.tags.put(PaperAdventure.asVanilla(tagKey.key()), nmsTag);
}
@Override
public void setTag(final TagKey<T> tagKey, final Collection<TypedKey<T>> values) {
final List<M> newList = List.copyOf(Collections2.transform(values, this::convert));
this.tags.put(PaperAdventure.asVanilla(tagKey.key()), newList);
}
}

128
paper-server/src/main/java/io/papermc/paper/tag/PaperPreFlattenTagRegistrar.java Normal file
View File

@@ -0,0 +1,128 @@
package io.papermc.paper.tag;
import com.google.common.base.Preconditions;
import com.google.common.collect.Collections2;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import io.papermc.paper.adventure.PaperAdventure;
import io.papermc.paper.plugin.bootstrap.BootstrapContext;
import io.papermc.paper.plugin.lifecycle.event.registrar.PaperRegistrar;
import io.papermc.paper.registry.RegistryKey;
import io.papermc.paper.registry.tag.TagKey;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.tags.TagLoader;
import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;
import org.checkerframework.framework.qual.DefaultQualifier;
@SuppressWarnings("BoundedWildcard")
@DefaultQualifier(NonNull.class)
public class PaperPreFlattenTagRegistrar<T> implements PaperRegistrar<BootstrapContext>, PreFlattenTagRegistrar<T> {
public final Map<ResourceLocation, List<TagLoader.EntryWithSource>> tags;
private final RegistryKey<T> registryKey;
private @Nullable BootstrapContext owner;
public PaperPreFlattenTagRegistrar(
final Map<ResourceLocation, List<TagLoader.EntryWithSource>> tags,
final TagEventConfig<?, T> config
) {
this.tags = new HashMap<>(tags);
this.registryKey = config.apiRegistryKey();
}
@Override
public void setCurrentContext(final @Nullable BootstrapContext owner) {
this.owner = owner;
}
@Override
public RegistryKey<T> registryKey() {
return this.registryKey;
}
@Override
public Map<TagKey<T>, Collection<TagEntry<T>>> getAllTags() {
final ImmutableMap.Builder<TagKey<T>, Collection<io.papermc.paper.tag.TagEntry<T>>> builder = ImmutableMap.builderWithExpectedSize(this.tags.size());
for (final Map.Entry<ResourceLocation, List<TagLoader.EntryWithSource>> entry : this.tags.entrySet()) {
final TagKey<T> key = TagKey.create(this.registryKey, CraftNamespacedKey.fromMinecraft(entry.getKey()));
builder.put(key, convert(entry.getValue()));
}
return builder.build();
}
private static <T> List<io.papermc.paper.tag.TagEntry<T>> convert(final List<TagLoader.EntryWithSource> nmsEntries) {
return Collections.unmodifiableList(Lists.transform(nmsEntries, PaperPreFlattenTagRegistrar::convert));
}
private static <T> io.papermc.paper.tag.TagEntry<T> convert(final TagLoader.EntryWithSource nmsEntry) {
return new TagEntryImpl<>(CraftNamespacedKey.fromMinecraft(nmsEntry.entry().id), nmsEntry.entry().tag, nmsEntry.entry().required);
}
private TagLoader.EntryWithSource convert(final TagEntry<T> entry) {
Preconditions.checkState(this.owner != null, "Owner is not set");
final ResourceLocation vanilla = PaperAdventure.asVanilla(entry.key());
final net.minecraft.tags.TagEntry nmsEntry;
if (entry.isTag()) {
if (entry.isRequired()) {
nmsEntry = net.minecraft.tags.TagEntry.tag(vanilla);
} else {
nmsEntry = net.minecraft.tags.TagEntry.optionalTag(vanilla);
}
} else {
if (entry.isRequired()) {
nmsEntry = net.minecraft.tags.TagEntry.element(vanilla);
} else {
nmsEntry = net.minecraft.tags.TagEntry.optionalElement(vanilla);
}
}
return new TagLoader.EntryWithSource(nmsEntry, this.owner.getPluginMeta().getDisplayName());
}
@Override
public boolean hasTag(final TagKey<T> tagKey) {
return this.tags.containsKey(PaperAdventure.asVanilla(tagKey.key()));
}
private List<TagLoader.EntryWithSource> getNmsTag(final TagKey<T> tagKey, boolean create) {
final ResourceLocation vanillaKey = PaperAdventure.asVanilla(tagKey.key());
List<TagLoader.EntryWithSource> tag = this.tags.get(vanillaKey);
if (tag == null) {
if (create) {
tag = this.tags.computeIfAbsent(vanillaKey, k -> new ArrayList<>());
} else {
throw new NoSuchElementException("Tag " + tagKey + " is not present");
}
}
return tag;
}
@Override
public List<TagEntry<T>> getTag(final TagKey<T> tagKey) {
return convert(this.getNmsTag(tagKey, false));
}
@Override
public void addToTag(final TagKey<T> tagKey, final Collection<TagEntry<T>> entries) {
final List<TagLoader.EntryWithSource> nmsTag = new ArrayList<>(this.getNmsTag(tagKey, true));
for (final TagEntry<T> tagEntry : entries) {
nmsTag.add(this.convert(tagEntry));
}
this.tags.put(PaperAdventure.asVanilla(tagKey.key()), nmsTag);
}
@Override
public void setTag(final TagKey<T> tagKey, final Collection<TagEntry<T>> entries) {
final List<TagLoader.EntryWithSource> newList = List.copyOf(Collections2.transform(entries, this::convert));
this.tags.put(PaperAdventure.asVanilla(tagKey.key()), newList);
}
}

105
paper-server/src/main/java/io/papermc/paper/tag/PaperTagListenerManager.java Normal file
View File

@@ -0,0 +1,105 @@
package io.papermc.paper.tag;
import io.papermc.paper.plugin.bootstrap.BootstrapContext;
import io.papermc.paper.plugin.lifecycle.event.LifecycleEventRunner;
import io.papermc.paper.plugin.lifecycle.event.registrar.ReloadableRegistrarEvent;
import io.papermc.paper.plugin.lifecycle.event.types.AbstractLifecycleEventType;
import io.papermc.paper.plugin.lifecycle.event.types.PrioritizableLifecycleEventType;
import io.papermc.paper.registry.PaperRegistries;
import io.papermc.paper.registry.RegistryKey;
import io.papermc.paper.registry.event.RegistryEventMap;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import net.minecraft.core.Holder;
import net.minecraft.core.Registry;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.tags.TagLoader;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;
import org.checkerframework.framework.qual.DefaultQualifier;
@DefaultQualifier(NonNull.class)
public class PaperTagListenerManager {
public static final String PRE_FLATTEN_EVENT_NAME = "pre-flatten";
public static final String POST_FLATTEN_EVENT_NAME = "post-flatten";
public static final PaperTagListenerManager INSTANCE = new PaperTagListenerManager();
public final RegistryEventMap preFlatten = new RegistryEventMap(PRE_FLATTEN_EVENT_NAME);
public final RegistryEventMap postFlatten = new RegistryEventMap(POST_FLATTEN_EVENT_NAME);
private PaperTagListenerManager() {
}
public <A> Map<ResourceLocation, List<TagLoader.EntryWithSource>> firePreFlattenEvent(
final Map<ResourceLocation, List<TagLoader.EntryWithSource>> initial,
final @Nullable TagEventConfig<?, A> config
) {
if (config == null || config.preFlatten() == null || !config.preFlatten().hasHandlers()) {
return initial;
}
final PaperPreFlattenTagRegistrar<A> registrar = new PaperPreFlattenTagRegistrar<>(initial, config);
LifecycleEventRunner.INSTANCE.callReloadableRegistrarEvent(
config.preFlatten(),
registrar,
BootstrapContext.class,
config.cause()
);
return Map.copyOf(registrar.tags);
}
public <M, A> Map<ResourceLocation, List<M>> firePostFlattenEvent(
final Map<ResourceLocation, List<M>> initial,
final @Nullable TagEventConfig<M, A> config
) {
if (config == null || config.postFlatten() == null || !config.postFlatten().hasHandlers()) {
return initial;
}
final PaperPostFlattenTagRegistrar<M, A> registrar = new PaperPostFlattenTagRegistrar<>(initial, config);
LifecycleEventRunner.INSTANCE.callReloadableRegistrarEvent(
config.postFlatten(),
registrar,
BootstrapContext.class,
config.cause()
);
return Map.copyOf(registrar.tags);
}
public <M, B> @Nullable TagEventConfig<Holder<M>, B> createEventConfig(final Registry<M> registry, final ReloadableRegistrarEvent.Cause cause) {
if (PaperRegistries.getEntry(registry.key()) == null) {
// TODO probably should be able to modify every registry
return null;
}
final RegistryKey<B> registryKey = PaperRegistries.registryFromNms(registry.key());
@Nullable AbstractLifecycleEventType<BootstrapContext, ReloadableRegistrarEvent<PreFlattenTagRegistrar<B>>, ?> preFlatten = null;
if (this.preFlatten.hasHandlers(registryKey)) {
preFlatten = (AbstractLifecycleEventType<BootstrapContext, ReloadableRegistrarEvent<PreFlattenTagRegistrar<B>>, ?>) this.preFlatten.<B, ReloadableRegistrarEvent<PreFlattenTagRegistrar<B>>>getEventType(registryKey);
}
@Nullable AbstractLifecycleEventType<BootstrapContext, ReloadableRegistrarEvent<PostFlattenTagRegistrar<B>>, ?> postFlatten = null;
if (this.postFlatten.hasHandlers(registryKey)) {
postFlatten = (AbstractLifecycleEventType<BootstrapContext, ReloadableRegistrarEvent<PostFlattenTagRegistrar<B>>, ?>) this.postFlatten.<B, ReloadableRegistrarEvent<PostFlattenTagRegistrar<B>>>getEventType(registryKey);
}
return new TagEventConfig<>(
preFlatten,
postFlatten,
cause,
registry::get,
h -> ((Holder.Reference<M>) h).key().location(),
PaperRegistries.registryFromNms(registry.key())
);
}
public <T> PrioritizableLifecycleEventType.Simple<BootstrapContext, ReloadableRegistrarEvent<PreFlattenTagRegistrar<T>>> getPreFlattenType(final RegistryKey<T> registryKey) {
return this.preFlatten.getOrCreate(registryKey, (ignored, name) -> {
return new PrioritizableLifecycleEventType.Simple<>(name, BootstrapContext.class);
});
}
public <T> PrioritizableLifecycleEventType.Simple<BootstrapContext, ReloadableRegistrarEvent<PostFlattenTagRegistrar<T>>> getPostFlattenType(final RegistryKey<T> registryKey) {
return this.postFlatten.getOrCreate(registryKey, (ignored, name) -> {
return new PrioritizableLifecycleEventType.Simple<>(name, BootstrapContext.class);
});
}
}

23
paper-server/src/main/java/io/papermc/paper/tag/TagEventConfig.java Normal file
View File

@@ -0,0 +1,23 @@
package io.papermc.paper.tag;
import io.papermc.paper.plugin.bootstrap.BootstrapContext;
import io.papermc.paper.plugin.lifecycle.event.registrar.ReloadableRegistrarEvent;
import io.papermc.paper.plugin.lifecycle.event.types.AbstractLifecycleEventType;
import io.papermc.paper.registry.RegistryKey;
import java.util.Optional;
import java.util.function.Function;
import net.minecraft.resources.ResourceLocation;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;
import org.checkerframework.framework.qual.DefaultQualifier;
@DefaultQualifier(NonNull.class)
public record TagEventConfig<M, A>(
@Nullable AbstractLifecycleEventType<BootstrapContext, ? extends ReloadableRegistrarEvent<PreFlattenTagRegistrar<A>>, ?> preFlatten,
@Nullable AbstractLifecycleEventType<BootstrapContext, ? extends ReloadableRegistrarEvent<PostFlattenTagRegistrar<A>>, ?> postFlatten,
ReloadableRegistrarEvent.Cause cause,
Function<ResourceLocation, Optional<? extends M>> fromIdConverter,
Function<M, ResourceLocation> toIdConverter,
RegistryKey<A> apiRegistryKey
) {
}