/*
* Minecraft Forge
* Copyright (c) 2016-2020.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation version 2.1
* of the License.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
package net.minecraftforge.registries;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.event.RegistryEvent;
import net.minecraftforge.eventbus.api.EventPriority;
import net.minecraftforge.eventbus.api.IEventBus;
import net.minecraftforge.eventbus.api.SubscribeEvent;
import net.minecraftforge.fml.RegistryObject;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.Set;
import java.util.function.Supplier;
import com.google.common.reflect.TypeToken;
/**
* Utility class to help with managing registry entries.
* Maintains a list of all suppliers for entries and registers them during the proper Register event.
* Suppliers should return NEW instances every time.
*
*Example Usage:
*
* private static final DeferredRegister- ITEMS = DeferredRegister.create(ForgeRegistries.ITEMS, MODID);
* private static final DeferredRegister BLOCKS = DeferredRegister.create(ForgeRegistries.BLOCKS, MODID);
*
* public static final RegistryObject ROCK_BLOCK = BLOCKS.register("rock", () -> new Block(Block.Properties.create(Material.ROCK)));
* public static final RegistryObject
- ROCK_ITEM = ITEMS.register("rock", () -> new BlockItem(ROCK_BLOCK.get(), new Item.Properties().group(ItemGroup.MISC)));
*
* public ExampleMod() {
* ITEMS.register(FMLJavaModLoadingContext.get().getModEventBus());
* BLOCKS.register(FMLJavaModLoadingContext.get().getModEventBus());
* }
*
*
* @param The base registry type, must be a concrete base class, do not use subclasses or wild cards.
*/
public class DeferredRegister>
{
/**
* Use for vanilla/forge registries. See example above.
*/
public static > DeferredRegister create(IForgeRegistry reg, String modid)
{
return new DeferredRegister(reg, modid);
}
/**
* Use for custom registries that are made during the NewRegistry event.
*/
public static > DeferredRegister create(Class base, String modid)
{
return new DeferredRegister(base, modid);
}
private final Class superType;
private final String modid;
private final Map, Supplier extends T>> entries = new LinkedHashMap<>();
private final Set> entriesView = Collections.unmodifiableSet(entries.keySet());
private IForgeRegistry type;
private Supplier> registryFactory;
private boolean seenRegisterEvent = false;
private DeferredRegister(Class base, String modid)
{
this.superType = base;
this.modid = modid;
}
private DeferredRegister(IForgeRegistry reg, String modid)
{
this(reg.getRegistrySuperType(), modid);
this.type = reg;
}
/**
* Adds a new supplier to the list of entries to be registered, and returns a RegistryObject that will be populated with the created entry automatically.
*
* @param name The new entry's name, it will automatically have the modid prefixed.
* @param sup A factory for the new entry, it should return a new instance every time it is called.
* @return A RegistryObject that will be updated with when the entries in the registry change.
*/
@SuppressWarnings("unchecked")
public RegistryObject register(final String name, final Supplier extends I> sup)
{
if (seenRegisterEvent)
throw new IllegalStateException("Cannot register new entries to DeferredRegister after RegistryEvent.Register has been fired.");
Objects.requireNonNull(name);
Objects.requireNonNull(sup);
final ResourceLocation key = new ResourceLocation(modid, name);
RegistryObject ret;
if (this.type != null)
ret = RegistryObject.of(key, this.type);
else if (this.superType != null)
ret = RegistryObject.of(key, this.superType, this.modid);
else
throw new IllegalStateException("Could not create RegistryObject in DeferredRegister");
if (entries.putIfAbsent((RegistryObject) ret, () -> sup.get().setRegistryName(key)) != null) {
throw new IllegalArgumentException("Duplicate registration " + name);
}
return ret;
}
/**
* For custom registries only, fills the {@link #registryFactory} to be called later see {@link #register(IEventBus)}
*
* Calls {@link RegistryBuilder#setName} and {@link RegistryBuilder#setType} automatically.
*
* @param name Path of the registry's {@link ResourceLocation}
* @param sup Supplier of the RegistryBuilder that is called to fill {@link #type} during the NewRegistry event
* @return A supplier of the {@link IForgeRegistry} created by the builder.
*/
public Supplier> makeRegistry(final String name, final Supplier> sup) {
if (this.superType == null)
throw new IllegalStateException("Cannot create a registry without specifying a base type");
if (this.type != null || this.registryFactory != null)
throw new IllegalStateException("Cannot create a registry for a type that already exists");
this.registryFactory = () -> sup.get().setName(new ResourceLocation(modid, name)).setType(this.superType);
return () -> this.type;
}
/**
* Adds our event handler to the specified event bus, this MUST be called in order for this class to function.
* See the example usage.
*
* @param bus The Mod Specific event bus.
*/
public void register(IEventBus bus)
{
bus.register(new EventDispatcher(this));
if (this.type == null && this.registryFactory != null) {
bus.addListener(this::createRegistry);
}
}
public static class EventDispatcher {
private final DeferredRegister> register;
public EventDispatcher(final DeferredRegister> register) {
this.register = register;
}
@SubscribeEvent
public void handleEvent(RegistryEvent.Register> event) {
register.addEntries(event);
}
}
/**
* @return The unmodifiable view of registered entries. Useful for bulk operations on all values.
*/
public Collection> getEntries()
{
return entriesView;
}
private void addEntries(RegistryEvent.Register> event)
{
if (this.type == null && this.registryFactory == null)
{
//If there is no type yet and we don't have a registry factory, attempt to capture the registry
//Note: This will only ever get run on the first registry event, as after that time,
// the type will no longer be null. This is needed here rather than during the NewRegistry event
// to ensure that mods can properly use deferred registers for custom registries added by other mods
captureRegistry();
}
if (this.type != null && event.getGenericType() == this.type.getRegistrySuperType())
{
this.seenRegisterEvent = true;
@SuppressWarnings("unchecked")
IForgeRegistry reg = (IForgeRegistry)event.getRegistry();
for (Entry, Supplier extends T>> e : entries.entrySet())
{
reg.register(e.getValue().get());
e.getKey().updateReference(reg);
}
}
}
private void createRegistry(RegistryEvent.NewRegistry event)
{
this.type = this.registryFactory.get().create();
}
private void captureRegistry()
{
if (this.superType != null)
{
this.type = RegistryManager.ACTIVE.getRegistry(this.superType);
if (this.type == null)
throw new IllegalStateException("Unable to find registry for type " + this.superType.getName() + " for modid \"" + modid + "\" after NewRegistry event");
}
else
throw new IllegalStateException("Unable to find registry for mod \"" + modid + "\" No lookup criteria specified.");
}
}