RegistrySetBuilder.java

net.minecraft.core.RegistrySetBuilder

信息

• 全限定名：net.minecraft.core.RegistrySetBuilder
• 类型：public class
• 包：net.minecraft.core
• 源码路径：src/main/java/net/minecraft/core/RegistrySetBuilder.java
• 起始行号：L26
• 职责：

  TODO

字段/常量

• entries
  • 类型: List<RegistrySetBuilder.RegistryStub<?>>
  • 修饰符: private final
  • 源码定位: L27
  • 说明:

    TODO

内部类/嵌套类型

• net.minecraft.core.RegistrySetBuilder.Entry

  • 类型: record
  • 修饰符: package-private
  • 源码定位: L82
  • 说明:

    TODO

• net.minecraft.core.RegistrySetBuilder.BuildState

  • 类型: record
  • 修饰符: private
  • 源码定位: L232
  • 说明:

    TODO

• net.minecraft.core.RegistrySetBuilder.EmptyTagLookup

  • 类型: class
  • 修饰符: private abstract static
  • 源码定位: L299
  • 说明:

    TODO

• net.minecraft.core.RegistrySetBuilder.EmptyTagLookupWrapper

  • 类型: class
  • 修饰符: private static
  • 源码定位: L312
  • 说明:

    TODO

• net.minecraft.core.RegistrySetBuilder.EmptyTagRegistryLookup

  • 类型: class
  • 修饰符: private abstract static
  • 源码定位: L326
  • 说明:

    TODO

• net.minecraft.core.RegistrySetBuilder.LazyHolder

  • 类型: class
  • 修饰符: private static
  • 源码定位: L337
  • 说明:

    TODO

• net.minecraft.core.RegistrySetBuilder.PatchedRegistries

  • 类型: record
  • 修饰符: public
  • 源码定位: L360
  • 说明:

    TODO

• net.minecraft.core.RegistrySetBuilder.RegisteredValue

  • 类型: record
  • 修饰符: private
  • 源码定位: L363
  • 说明:

    TODO

• net.minecraft.core.RegistrySetBuilder.RegistryBootstrap

  • 类型: interface
  • 修饰符: public
  • 源码定位: L367
  • 说明:

    TODO

• net.minecraft.core.RegistrySetBuilder.RegistryContents

  • 类型: record
  • 修饰符: private
  • 源码定位: L371
  • 说明:

    TODO

• net.minecraft.core.RegistrySetBuilder.RegistryStub

  • 类型: record
  • 修饰符: private
  • 源码定位: L388
  • 说明:

    TODO

• net.minecraft.core.RegistrySetBuilder.UniversalLookup

  • 类型: class
  • 修饰符: private static
  • 源码定位: L412
  • 说明:

    TODO

• net.minecraft.core.RegistrySetBuilder.UniversalOwner

  • 类型: class
  • 修饰符: private static
  • 源码定位: L429
  • 说明:

    TODO

• net.minecraft.core.RegistrySetBuilder.ValueAndHolder

  • 类型: record
  • 修饰符: private
  • 源码定位: L435
  • 说明:

    TODO

构造器

• 无

方法

下面的方法块按源码顺序生成。

private static <T> HolderGetter<T> wrapContextLookup(HolderLookup.RegistryLookup<T> original) @ L29

• 方法名：wrapContextLookup
• 源码定位：L29
• 返回类型： HolderGetter
• 修饰符：private static

参数:

• original: HolderLookup.RegistryLookup

说明:

TODO

private static <T> HolderLookup.RegistryLookup<T> lookupFromMap(ResourceKey<?extends Registry<?extends T>> key, Lifecycle lifecycle, HolderOwner<T> owner, Map<ResourceKey<T>,Holder.Reference<T>> entries) @ L38

• 方法名：lookupFromMap
• 源码定位：L38
• 返回类型： HolderLookup.RegistryLookup
• 修饰符：private static

参数:

• key: ResourceKey<?extends Registry<?extends T>>
• lifecycle: Lifecycle
• owner: HolderOwner
• entries: Map<ResourceKey,Holder.Reference>

说明:

TODO

public <T> RegistrySetBuilder add(ResourceKey<?extends Registry<T>> key, Lifecycle lifecycle, RegistrySetBuilder.RegistryBootstrap<T> bootstrap) @ L64

• 方法名：add
• 源码定位：L64
• 返回类型： RegistrySetBuilder
• 修饰符：public

参数:

• key: ResourceKey<?extends Registry>
• lifecycle: Lifecycle
• bootstrap: RegistrySetBuilder.RegistryBootstrap

说明:

TODO

public <T> RegistrySetBuilder add(ResourceKey<?extends Registry<T>> key, RegistrySetBuilder.RegistryBootstrap<T> bootstrap) @ L69

• 方法名：add
• 源码定位：L69
• 返回类型： RegistrySetBuilder
• 修饰符：public

参数:

• key: ResourceKey<?extends Registry>
• bootstrap: RegistrySetBuilder.RegistryBootstrap

说明:

TODO

private RegistrySetBuilder.BuildState createState(RegistryAccess context) @ L73

• 方法名：createState
• 源码定位：L73
• 返回类型：RegistrySetBuilder.BuildState
• 修饰符：private

参数:

• context: RegistryAccess

说明:

TODO

private static HolderLookup.Provider buildProviderWithContext(RegistrySetBuilder.UniversalOwner owner, RegistryAccess context, Stream<HolderLookup.RegistryLookup<?>> newRegistries) @ L79

• 方法名：buildProviderWithContext
• 源码定位：L79
• 返回类型：HolderLookup.Provider
• 修饰符：private static

参数:

• owner: RegistrySetBuilder.UniversalOwner
• context: RegistryAccess
• newRegistries: Stream<HolderLookup.RegistryLookup<?>>

说明:

TODO

public HolderLookup.Provider build(RegistryAccess context) @ L131

• 方法名：build
• 源码定位：L131
• 返回类型：HolderLookup.Provider
• 修饰符：public

参数:

• context: RegistryAccess

说明:

TODO

private HolderLookup.Provider createLazyFullPatchedRegistries(RegistryAccess context, HolderLookup.Provider fallbackProvider, Cloner.Factory clonerFactory, Map<ResourceKey<?extends Registry<?>>,RegistrySetBuilder.RegistryContents<?>> newRegistries, HolderLookup.Provider patchOnlyRegistries) @ L143

• 方法名：createLazyFullPatchedRegistries
• 源码定位：L143
• 返回类型：HolderLookup.Provider
• 修饰符：private

参数:

• context: RegistryAccess
• fallbackProvider: HolderLookup.Provider
• clonerFactory: Cloner.Factory
• newRegistries: Map<ResourceKey>,RegistrySetBuilder.RegistryContents<?>>
• patchOnlyRegistries: HolderLookup.Provider

说明:

TODO

private <T> HolderLookup.RegistryLookup<T> createLazyFullPatchedRegistries(HolderOwner<T> owner, Cloner.Factory clonerFactory, ResourceKey<?extends Registry<?extends T>> registryKey, HolderLookup.Provider patchProvider, HolderLookup.Provider fallbackProvider, MutableObject<HolderLookup.Provider> targetProvider) @ L170

• 方法名：createLazyFullPatchedRegistries
• 源码定位：L170
• 返回类型： HolderLookup.RegistryLookup
• 修饰符：private

参数:

• owner: HolderOwner
• clonerFactory: Cloner.Factory
• registryKey: ResourceKey<?extends Registry<?extends T>>
• patchProvider: HolderLookup.Provider
• fallbackProvider: HolderLookup.Provider
• targetProvider: MutableObject<HolderLookup.Provider>

说明:

TODO

public RegistrySetBuilder.PatchedRegistries buildPatch(RegistryAccess context, HolderLookup.Provider fallbackProvider, Cloner.Factory clonerFactory) @ L204

• 方法名：buildPatch
• 源码定位：L204
• 返回类型：RegistrySetBuilder.PatchedRegistries
• 修饰符：public

参数:

• context: RegistryAccess
• fallbackProvider: HolderLookup.Provider
• clonerFactory: Cloner.Factory

说明:

TODO

代码

public class RegistrySetBuilder {
    private final List<RegistrySetBuilder.RegistryStub<?>> entries = new ArrayList<>();
 
    private static <T> HolderGetter<T> wrapContextLookup(HolderLookup.RegistryLookup<T> original) {
        return new RegistrySetBuilder.EmptyTagLookup<T>(original) {
            @Override
            public Optional<Holder.Reference<T>> get(ResourceKey<T> id) {
                return original.get(id);
            }
        };
    }
 
    private static <T> HolderLookup.RegistryLookup<T> lookupFromMap(
        ResourceKey<? extends Registry<? extends T>> key, Lifecycle lifecycle, HolderOwner<T> owner, Map<ResourceKey<T>, Holder.Reference<T>> entries
    ) {
        return new RegistrySetBuilder.EmptyTagRegistryLookup<T>(owner) {
            @Override
            public ResourceKey<? extends Registry<? extends T>> key() {
                return key;
            }
 
            @Override
            public Lifecycle registryLifecycle() {
                return lifecycle;
            }
 
            @Override
            public Optional<Holder.Reference<T>> get(ResourceKey<T> id) {
                return Optional.ofNullable(entries.get(id));
            }
 
            @Override
            public Stream<Holder.Reference<T>> listElements() {
                return entries.values().stream();
            }
        };
    }
 
    public <T> RegistrySetBuilder add(ResourceKey<? extends Registry<T>> key, Lifecycle lifecycle, RegistrySetBuilder.RegistryBootstrap<T> bootstrap) {
        this.entries.add(new RegistrySetBuilder.RegistryStub<>(key, lifecycle, bootstrap));
        return this;
    }
 
    public <T> RegistrySetBuilder add(ResourceKey<? extends Registry<T>> key, RegistrySetBuilder.RegistryBootstrap<T> bootstrap) {
        return this.add(key, Lifecycle.stable(), bootstrap);
    }
 
    private RegistrySetBuilder.BuildState createState(RegistryAccess context) {
        RegistrySetBuilder.BuildState state = RegistrySetBuilder.BuildState.create(context, this.entries.stream().map(RegistrySetBuilder.RegistryStub::key));
        this.entries.forEach(e -> e.apply(state));
        return state;
    }
 
    private static HolderLookup.Provider buildProviderWithContext(
        RegistrySetBuilder.UniversalOwner owner, RegistryAccess context, Stream<HolderLookup.RegistryLookup<?>> newRegistries
    ) {
        record Entry<T>(HolderLookup.RegistryLookup<T> lookup, RegistryOps.RegistryInfo<T> opsInfo) {
            public static <T> Entry<T> createForContextRegistry(HolderLookup.RegistryLookup<T> registryLookup) {
                return new Entry<>(
                    new RegistrySetBuilder.EmptyTagLookupWrapper<>(registryLookup, registryLookup), RegistryOps.RegistryInfo.fromRegistryLookup(registryLookup)
                );
            }
 
            public static <T> Entry<T> createForNewRegistry(RegistrySetBuilder.UniversalOwner owner, HolderLookup.RegistryLookup<T> registryLookup) {
                return new Entry<>(
                    new RegistrySetBuilder.EmptyTagLookupWrapper<>(owner.cast(), registryLookup),
                    new RegistryOps.RegistryInfo<>(owner.cast(), registryLookup, registryLookup.registryLifecycle())
                );
            }
        }
 
        final Map<ResourceKey<? extends Registry<?>>, Entry<?>> lookups = new HashMap<>();
        context.registries().forEach(contextRegistry -> lookups.put(contextRegistry.key(), Entry.createForContextRegistry(contextRegistry.value())));
        newRegistries.forEach(newRegistry -> lookups.put(newRegistry.key(), Entry.createForNewRegistry(owner, newRegistry)));
        return new HolderLookup.Provider() {
            @Override
            public Stream<ResourceKey<? extends Registry<?>>> listRegistryKeys() {
                return lookups.keySet().stream();
            }
 
            private <T> Optional<Entry<T>> getEntry(ResourceKey<? extends Registry<? extends T>> key) {
                return Optional.ofNullable((Entry<T>)lookups.get(key));
            }
 
            @Override
            public <T> Optional<HolderLookup.RegistryLookup<T>> lookup(ResourceKey<? extends Registry<? extends T>> key) {
                return this.getEntry(key).map(Entry::lookup);
            }
 
            @Override
            public <V> RegistryOps<V> createSerializationContext(DynamicOps<V> parent) {
                return RegistryOps.create(parent, new RegistryOps.RegistryInfoLookup() {
                    {
                        
                    }
 
                    @Override
                    public <T> Optional<RegistryOps.RegistryInfo<T>> lookup(ResourceKey<? extends Registry<? extends T>> registryKey) {
                        return getEntry(registryKey).map(Entry::opsInfo);
                    }
                });
            }
        };
    }
 
    public HolderLookup.Provider build(RegistryAccess context) {
        RegistrySetBuilder.BuildState state = this.createState(context);
        Stream<HolderLookup.RegistryLookup<?>> newRegistries = this.entries
            .stream()
            .map(stub -> stub.collectRegisteredValues(state).buildAsLookup(state.owner));
        HolderLookup.Provider result = buildProviderWithContext(state.owner, context, newRegistries);
        state.reportNotCollectedHolders();
        state.reportUnclaimedRegisteredValues();
        state.throwOnError();
        return result;
    }
 
    private HolderLookup.Provider createLazyFullPatchedRegistries(
        RegistryAccess context,
        HolderLookup.Provider fallbackProvider,
        Cloner.Factory clonerFactory,
        Map<ResourceKey<? extends Registry<?>>, RegistrySetBuilder.RegistryContents<?>> newRegistries,
        HolderLookup.Provider patchOnlyRegistries
    ) {
        RegistrySetBuilder.UniversalOwner fullPatchedOwner = new RegistrySetBuilder.UniversalOwner();
        MutableObject<HolderLookup.Provider> resultReference = new MutableObject<>();
        List<HolderLookup.RegistryLookup<?>> lazyFullRegistries = newRegistries.keySet()
            .stream()
            .map(
                registryKey -> this.createLazyFullPatchedRegistries(
                    fullPatchedOwner,
                    clonerFactory,
                    (ResourceKey<? extends Registry<? extends Object>>)registryKey,
                    patchOnlyRegistries,
                    fallbackProvider,
                    resultReference
                )
            )
            .collect(Collectors.toUnmodifiableList());
        HolderLookup.Provider result = buildProviderWithContext(fullPatchedOwner, context, lazyFullRegistries.stream());
        resultReference.setValue(result);
        return result;
    }
 
    private <T> HolderLookup.RegistryLookup<T> createLazyFullPatchedRegistries(
        HolderOwner<T> owner,
        Cloner.Factory clonerFactory,
        ResourceKey<? extends Registry<? extends T>> registryKey,
        HolderLookup.Provider patchProvider,
        HolderLookup.Provider fallbackProvider,
        MutableObject<HolderLookup.Provider> targetProvider
    ) {
        Cloner<T> cloner = clonerFactory.cloner(registryKey);
        if (cloner == null) {
            throw new NullPointerException("No cloner for " + registryKey.identifier());
        } else {
            Map<ResourceKey<T>, Holder.Reference<T>> entries = new HashMap<>();
            HolderLookup.RegistryLookup<T> patchContents = patchProvider.lookupOrThrow(registryKey);
            patchContents.listElements().forEach(elementHolder -> {
                ResourceKey<T> elementKey = elementHolder.key();
                RegistrySetBuilder.LazyHolder<T> holder = new RegistrySetBuilder.LazyHolder<>(owner, elementKey);
                holder.supplier = () -> cloner.clone((T)elementHolder.value(), patchProvider, targetProvider.get());
                entries.put(elementKey, holder);
            });
            HolderLookup.RegistryLookup<T> fallbackContents = fallbackProvider.lookupOrThrow(registryKey);
            fallbackContents.listElements().forEach(elementHolder -> {
                ResourceKey<T> elementKey = elementHolder.key();
                entries.computeIfAbsent(elementKey, key -> {
                    RegistrySetBuilder.LazyHolder<T> holder = new RegistrySetBuilder.LazyHolder<>(owner, elementKey);
                    holder.supplier = () -> cloner.clone((T)elementHolder.value(), fallbackProvider, targetProvider.get());
                    return holder;
                });
            });
            Lifecycle lifecycle = patchContents.registryLifecycle().add(fallbackContents.registryLifecycle());
            return lookupFromMap(registryKey, lifecycle, owner, entries);
        }
    }
 
    public RegistrySetBuilder.PatchedRegistries buildPatch(RegistryAccess context, HolderLookup.Provider fallbackProvider, Cloner.Factory clonerFactory) {
        RegistrySetBuilder.BuildState state = this.createState(context);
        Map<ResourceKey<? extends Registry<?>>, RegistrySetBuilder.RegistryContents<?>> newRegistries = new HashMap<>();
        this.entries
            .stream()
            .map(stub -> stub.collectRegisteredValues(state))
            .forEach(e -> newRegistries.put(e.key, (RegistrySetBuilder.RegistryContents<?>)e));
        Set<ResourceKey<? extends Registry<?>>> contextRegistries = context.listRegistryKeys().collect(Collectors.toUnmodifiableSet());
        fallbackProvider.listRegistryKeys()
            .filter(k -> !contextRegistries.contains(k))
            .forEach(
                resourceKey -> newRegistries.putIfAbsent(
                    (ResourceKey<? extends Registry<?>>)resourceKey,
                    new RegistrySetBuilder.RegistryContents<>((ResourceKey<? extends Registry<?>>)resourceKey, Lifecycle.stable(), Map.of())
                )
            );
        Stream<HolderLookup.RegistryLookup<?>> dynamicRegistries = newRegistries.values()
            .stream()
            .map(registryContents -> registryContents.buildAsLookup(state.owner));
        HolderLookup.Provider patchOnlyRegistries = buildProviderWithContext(state.owner, context, dynamicRegistries);
        state.reportUnclaimedRegisteredValues();
        state.throwOnError();
        HolderLookup.Provider fullPatchedRegistries = this.createLazyFullPatchedRegistries(
            context, fallbackProvider, clonerFactory, newRegistries, patchOnlyRegistries
        );
        return new RegistrySetBuilder.PatchedRegistries(fullPatchedRegistries, patchOnlyRegistries);
    }
 
    private record BuildState(
        RegistrySetBuilder.UniversalOwner owner,
        RegistrySetBuilder.UniversalLookup lookup,
        Map<Identifier, HolderGetter<?>> registries,
        Map<ResourceKey<?>, RegistrySetBuilder.RegisteredValue<?>> registeredValues,
        List<RuntimeException> errors
    ) {
        public static RegistrySetBuilder.BuildState create(RegistryAccess context, Stream<ResourceKey<? extends Registry<?>>> newRegistries) {
            RegistrySetBuilder.UniversalOwner owner = new RegistrySetBuilder.UniversalOwner();
            List<RuntimeException> errors = new ArrayList<>();
            RegistrySetBuilder.UniversalLookup lookup = new RegistrySetBuilder.UniversalLookup(owner);
            Builder<Identifier, HolderGetter<?>> registries = ImmutableMap.builder();
            context.registries()
                .forEach(contextRegistry -> registries.put(contextRegistry.key().identifier(), RegistrySetBuilder.wrapContextLookup(contextRegistry.value())));
            newRegistries.forEach(newRegistry -> registries.put(newRegistry.identifier(), lookup));
            return new RegistrySetBuilder.BuildState(owner, lookup, registries.build(), new HashMap<>(), errors);
        }
 
        public <T> BootstrapContext<T> bootstrapContext() {
            return new BootstrapContext<T>() {
                {
                    Objects.requireNonNull(BuildState.this);
                }
 
                @Override
                public Holder.Reference<T> register(ResourceKey<T> key, T value, Lifecycle lifecycle) {
                    RegistrySetBuilder.RegisteredValue<?> previousValue = BuildState.this.registeredValues
                        .put(key, new RegistrySetBuilder.RegisteredValue(value, lifecycle));
                    if (previousValue != null) {
                        BuildState.this.errors
                            .add(new IllegalStateException("Duplicate registration for " + key + ", new=" + value + ", old=" + previousValue.value));
                    }
 
                    return BuildState.this.lookup.getOrCreate(key);
                }
 
                @Override
                public <S> HolderGetter<S> lookup(ResourceKey<? extends Registry<? extends S>> key) {
                    return (HolderGetter<S>)BuildState.this.registries.getOrDefault(key.identifier(), BuildState.this.lookup);
                }
            };
        }
 
        public void reportUnclaimedRegisteredValues() {
            this.registeredValues
                .forEach((key, registeredValue) -> this.errors.add(new IllegalStateException("Orpaned value " + registeredValue.value + " for key " + key)));
        }
 
        public void reportNotCollectedHolders() {
            for (ResourceKey<Object> key : this.lookup.holders.keySet()) {
                this.errors.add(new IllegalStateException("Unreferenced key: " + key));
            }
        }
 
        public void throwOnError() {
            if (!this.errors.isEmpty()) {
                IllegalStateException result = new IllegalStateException("Errors during registry creation");
 
                for (RuntimeException error : this.errors) {
                    result.addSuppressed(error);
                }
 
                throw result;
            }
        }
    }
 
    private abstract static class EmptyTagLookup<T> implements HolderGetter<T> {
        protected final HolderOwner<T> owner;
 
        protected EmptyTagLookup(HolderOwner<T> owner) {
            this.owner = owner;
        }
 
        @Override
        public Optional<HolderSet.Named<T>> get(TagKey<T> id) {
            return Optional.of(HolderSet.emptyNamed(this.owner, id));
        }
    }
 
    private static class EmptyTagLookupWrapper<T> extends RegistrySetBuilder.EmptyTagRegistryLookup<T> implements HolderLookup.RegistryLookup.Delegate<T> {
        private final HolderLookup.RegistryLookup<T> parent;
 
        private EmptyTagLookupWrapper(HolderOwner<T> owner, HolderLookup.RegistryLookup<T> parent) {
            super(owner);
            this.parent = parent;
        }
 
        @Override
        public HolderLookup.RegistryLookup<T> parent() {
            return this.parent;
        }
    }
 
    private abstract static class EmptyTagRegistryLookup<T> extends RegistrySetBuilder.EmptyTagLookup<T> implements HolderLookup.RegistryLookup<T> {
        protected EmptyTagRegistryLookup(HolderOwner<T> owner) {
            super(owner);
        }
 
        @Override
        public Stream<HolderSet.Named<T>> listTags() {
            throw new UnsupportedOperationException("Tags are not available in datagen");
        }
    }
 
    private static class LazyHolder<T> extends Holder.Reference<T> {
        private @Nullable Supplier<T> supplier;
 
        protected LazyHolder(HolderOwner<T> owner, @Nullable ResourceKey<T> key) {
            super(Holder.Reference.Type.STAND_ALONE, owner, key, null);
        }
 
        @Override
        protected void bindValue(T value) {
            super.bindValue(value);
            this.supplier = null;
        }
 
        @Override
        public T value() {
            if (this.supplier != null) {
                this.bindValue(this.supplier.get());
            }
 
            return super.value();
        }
    }
 
    public record PatchedRegistries(HolderLookup.Provider full, HolderLookup.Provider patches) {
    }
 
    private record RegisteredValue<T>(T value, Lifecycle lifecycle) {
    }
 
    @FunctionalInterface
    public interface RegistryBootstrap<T> {
        void run(BootstrapContext<T> registry);
    }
 
    private record RegistryContents<T>(
        ResourceKey<? extends Registry<? extends T>> key, Lifecycle lifecycle, Map<ResourceKey<T>, RegistrySetBuilder.ValueAndHolder<T>> values
    ) {
        public HolderLookup.RegistryLookup<T> buildAsLookup(RegistrySetBuilder.UniversalOwner owner) {
            Map<ResourceKey<T>, Holder.Reference<T>> entries = this.values
                .entrySet()
                .stream()
                .collect(Collectors.toUnmodifiableMap(java.util.Map.Entry::getKey, e -> {
                    RegistrySetBuilder.ValueAndHolder<T> entry = e.getValue();
                    Holder.Reference<T> holder = entry.holder().orElseGet(() -> Holder.Reference.createStandAlone(owner.cast(), e.getKey()));
                    holder.bindValue(entry.value().value());
                    return holder;
                }));
            return RegistrySetBuilder.lookupFromMap(this.key, this.lifecycle, owner.cast(), entries);
        }
    }
 
    private record RegistryStub<T>(ResourceKey<? extends Registry<T>> key, Lifecycle lifecycle, RegistrySetBuilder.RegistryBootstrap<T> bootstrap) {
        private void apply(RegistrySetBuilder.BuildState state) {
            this.bootstrap.run(state.bootstrapContext());
        }
 
        public RegistrySetBuilder.RegistryContents<T> collectRegisteredValues(RegistrySetBuilder.BuildState state) {
            Map<ResourceKey<T>, RegistrySetBuilder.ValueAndHolder<T>> result = new HashMap<>();
            Iterator<java.util.Map.Entry<ResourceKey<?>, RegistrySetBuilder.RegisteredValue<?>>> iterator = state.registeredValues.entrySet().iterator();
 
            while (iterator.hasNext()) {
                java.util.Map.Entry<ResourceKey<?>, RegistrySetBuilder.RegisteredValue<?>> entry = iterator.next();
                ResourceKey<?> key = entry.getKey();
                if (key.isFor(this.key)) {
                    RegistrySetBuilder.RegisteredValue<T> value = (RegistrySetBuilder.RegisteredValue<T>)entry.getValue();
                    Holder.Reference<T> holder = (Holder.Reference<T>)state.lookup.holders.remove(key);
                    result.put((ResourceKey<T>)key, new RegistrySetBuilder.ValueAndHolder<>(value, Optional.ofNullable(holder)));
                    iterator.remove();
                }
            }
 
            return new RegistrySetBuilder.RegistryContents<>(this.key, this.lifecycle, result);
        }
    }
 
    private static class UniversalLookup extends RegistrySetBuilder.EmptyTagLookup<Object> {
        private final Map<ResourceKey<Object>, Holder.Reference<Object>> holders = new HashMap<>();
 
        public UniversalLookup(HolderOwner<Object> owner) {
            super(owner);
        }
 
        @Override
        public Optional<Holder.Reference<Object>> get(ResourceKey<Object> id) {
            return Optional.of(this.getOrCreate(id));
        }
 
        private <T> Holder.Reference<T> getOrCreate(ResourceKey<T> id) {
            return (Holder.Reference<T>)this.holders.computeIfAbsent((ResourceKey<Object>)id, k -> Holder.Reference.createStandAlone(this.owner, (ResourceKey<Object>)k));
        }
    }
 
    private static class UniversalOwner implements HolderOwner<Object> {
        public <T> HolderOwner<T> cast() {
            return (HolderOwner<T>)this;
        }
    }
 
    private record ValueAndHolder<T>(RegistrySetBuilder.RegisteredValue<T> value, Optional<Holder.Reference<T>> holder) {
    }
}

引用的其他类

• Cloner

  • 引用位置: 参数

• Holder

  • 引用位置: 参数/方法调用
  • 关联成员: Holder.Reference.createStandAlone()

• HolderGetter

  • 引用位置: 返回值

• HolderLookup

  • 引用位置: 参数/方法调用/构造调用/返回值
  • 关联成员: HolderLookup.Provider(), Provider()

• HolderOwner

  • 引用位置: 参数

• HolderSet

  • 引用位置: 方法调用
  • 关联成员: HolderSet.emptyNamed()

• Registry

  • 引用位置: 参数

• RegistryAccess

  • 引用位置: 参数

• RegistryOps

  • 引用位置: 方法调用/构造调用
  • 关联成员: RegistryInfoLookup(), RegistryOps.RegistryInfo.fromRegistryLookup(), RegistryOps.RegistryInfoLookup(), RegistryOps.create()

• ResourceKey

  • 引用位置: 参数