nova/xyz.xenondevs.nova.registry/InstantBindMappedRegistry

InstantBindMappedRegistry

open class InstantBindMappedRegistry<T : Any>(resourceKey: ResourceKey<out Registry<T>>, lifecycle: Lifecycle) : MappedRegistry<T>

MappedRegistry implementation that binds the value to the Holder.Reference immediately after registering it instead of waiting for freeze to be called.

Inheritors

FuzzyMappedRegistry

Constructors

InstantBindMappedRegistry

constructor(resourceKey: ResourceKey<out Registry<T>>, lifecycle: Lifecycle)

Functions

asHolderIdMap

open fun asHolderIdMap(): IdMap<Holder<T>>

asLookup

open override fun asLookup(): HolderLookup.RegistryLookup<T>

asTagAddingLookup

open fun asTagAddingLookup(): HolderLookup.RegistryLookup<T>

bindTags

open override fun bindTags(p0: MutableMap<TagKey<T>, MutableList<Holder<T>>>)

byId

@Nullable

open override fun byId(p0: Int): T?

byIdOrThrow

open fun byIdOrThrow(index: Int): T

byNameBinaryAdapter

fun <T : Any> Registry<T>.byNameBinaryAdapter(): BinaryAdapter<T>

byNameCodec

open fun byNameCodec(): Codec<T>

byNameTypeSerializer

inline fun <T : Any> Registry<T>.byNameTypeSerializer(): TypeSerializer<T>

clearIntrusiveHolder

open fun clearIntrusiveHolder(p0: T)

contains

operator fun Registry<*>.contains(key: String): Boolean

containsKey

open override fun containsKey(p0: ResourceKey<T>): Boolean

open override fun containsKey(p0: ResourceLocation): Boolean

createIntrusiveHolder

open override fun createIntrusiveHolder(p0: T): Holder.Reference<T>

createRegistrationLookup

open override fun createRegistrationLookup(): HolderGetter<T>

entrySet

open override fun entrySet(): MutableSet<MutableMap.MutableEntry<ResourceKey<T>, T>>

filterInRange

fun Iterable<Player>.filterInRange(location: Location, maxDistance: Double): List<Player>

forEach

open fun forEach(p0: Consumer<in T>)

freeze

open override fun freeze(): Registry<T>

get

@Nullable

open operator override fun get(@Nullable p0: ResourceKey<T>?): T?

@Nullable

open operator override fun get(@Nullable p0: ResourceLocation?): T?

get

operator fun <T> Registry<T>.get(key: String): T?

getAny

open override fun getAny(): Optional<Holder.Reference<T>>

getHolder

open override fun getHolder(p0: Int): Optional<Holder.Reference<T>>

open override fun getHolder(p0: ResourceKey<T>): Optional<Holder.Reference<T>>

open override fun getHolder(p0: ResourceLocation): Optional<Holder.Reference<T>>

getHolder

fun <T> Registry<T>.getHolder(id: ResourceLocation): Holder<T>?

getHolderOrThrow

open fun getHolderOrThrow(key: ResourceKey<T>): Holder.Reference<T>

getHolderOrThrow

fun <T> Registry<T>.getHolderOrThrow(id: ResourceLocation): Holder<T>

getId

open override fun getId(@Nullable p0: T?): Int

getIdOrThrow

open fun getIdOrThrow(value: T): Int

getKey

@Nullable

open override fun getKey(p0: T): ResourceLocation?

getOptional

open fun getOptional(@Nullable key: ResourceKey<T>?): Optional<T>

open fun getOptional(@Nullable id: ResourceLocation?): Optional<T>

getOrCreateHolder

fun <T> Registry<T>.getOrCreateHolder(id: ResourceLocation): Holder<T>

getOrCreateTag

open override fun getOrCreateTag(p0: TagKey<T>): HolderSet.Named<T>

getOrThrow

open fun getOrThrow(key: ResourceKey<T>): T

getOrThrow

fun <T> Registry<T>.getOrThrow(key: String): T

fun <T> Registry<T>.getOrThrow(id: ResourceLocation): T

getRandom

open override fun getRandom(p0: RandomSource): Optional<Holder.Reference<T>>

getRandomElementOf

open fun getRandomElementOf(tag: TagKey<T>, random: RandomSource): Optional<Holder<T>>

getResourceKey

open override fun getResourceKey(p0: T): Optional<ResourceKey<T>>

getTag

open override fun getTag(p0: TagKey<T>): Optional<HolderSet.Named<T>>

getTagNames

open override fun getTagNames(): Stream<TagKey<T>>

getTagOrEmpty

open fun getTagOrEmpty(tag: TagKey<T>): MutableIterable<Holder<T>>

getTags

open override fun getTags(): Stream<Pair<TagKey<T>, HolderSet.Named<T>>>

holderByNameCodec

open fun holderByNameCodec(): Codec<Holder<T>>

holderOwner

open override fun holderOwner(): HolderOwner<T>

holders

open override fun holders(): Stream<Holder.Reference<T>>

isEmpty

open override fun isEmpty(): Boolean

iterator

open operator override fun iterator(): MutableIterator<T>

key

open override fun key(): ResourceKey<out Registry<T>>

keys

open override fun <U : Any> keys(dynamicOps: DynamicOps<U>): Stream<U>

keySet

open override fun keySet(): MutableSet<ResourceLocation>

open override fun register(key: ResourceKey<T>, value: T, info: RegistrationInfo): Holder.Reference<T>

fun <T : Any> WritableRegistry<T>.register(id: ResourceLocation, value: T): Holder.Reference<T>

registrationInfo

open override fun registrationInfo(p0: ResourceKey<T>): Optional<RegistrationInfo>

registryKeySet

open override fun registryKeySet(): MutableSet<ResourceKey<T>>

registryLifecycle

open override fun registryLifecycle(): Lifecycle

resetTags

open override fun resetTags()

set

operator fun <T : Any> WritableRegistry<T>.set(name: String, value: T)

operator fun <T : Any> WritableRegistry<T>.set(id: ResourceLocation, value: T)

operator fun <T : Any> WritableRegistry<T>.set(addon: Addon, key: String, value: T)

size

open override fun size(): Int

spliterator

open fun spliterator(): Spliterator<T>

stream

open fun stream(): Stream<T>

toHolderMap

fun <T> Registry<T>.toHolderMap(): Map<ResourceLocation, Holder<T>>

toMap

fun <T> Registry<T>.toMap(): Map<ResourceLocation, T>

toString

open override fun toString(): String

validateWrite

open fun validateWrite(p0: ResourceKey<T>)

wrapAsHolder

open override fun wrapAsHolder(p0: T): Holder<T>