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)

Properties

any

open override val any: Optional<Holder.Reference<T>>

isEmpty

open override val isEmpty: Boolean

Functions

asHolderIdMap

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

bindAllTagsToEmpty

open fun bindAllTagsToEmpty()

bindTag

open fun bindTag(tag: TagKey<T>, values: List<Holder<T>>)

byId

open fun byId(id: Int): @Nullable T?

byIdOrThrow

open fun byIdOrThrow(id: Int): T

byNameBinarySerializer

fun <T : Any> Registry<T>.byNameBinarySerializer(): BinarySerializer<T>

byNameCodec

open fun byNameCodec(): Codec<T>

canSerializeIn

open fun canSerializeIn(owner: HolderOwner<T>): Boolean

clearIntrusiveHolder

open fun clearIntrusiveHolder(instance: T)

contains

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

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

containsKey

open fun containsKey(key: Identifier): Boolean

open fun containsKey(key: ResourceKey<T>): Boolean

createIntrusiveHolder

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

createRegistrationLookup

open fun createRegistrationLookup(): HolderGetter<T>

entrySet

open fun entrySet(): Set<Map.Entry<ResourceKey<T>, T>>

filterElements

open fun filterElements(predicate: Predicate<T>): HolderLookup.RegistryLookup<T>

filterFeatures

open fun filterFeatures(enabledFeatures: FeatureFlagSet): HolderLookup.RegistryLookup<T>

filterInRange

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

freeze

open fun freeze(): Registry<T>

get

open operator fun get(resourceKey: ResourceKey<T>): Optional<Holder.Reference<T>>

open operator fun get(tagKey: TagKey<T>): Optional<HolderSet.Named<T>>

open operator fun get(index: Int): Optional<Holder.Reference<T>>

open operator fun get(key: Identifier): Optional<Holder.Reference<T>>

get

operator fun <T : Any> Registry<T>.get(key: String): Optional<Holder.Reference<T>>

getAny

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

getId

open fun getId(value: @Nullable T?): Int

getIdOrThrow

open fun getIdOrThrow(value: T): Int

getKey

open fun getKey(value: T): @Nullable Identifier?

getOptional

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

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

getOrCreateHolder

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

getOrNull

fun <T : Any> Registry<T>.getOrNull(key: String): Holder.Reference<T>?

fun <T : Any> Registry<T>.getOrNull(key: Key): Holder.Reference<T>?

fun <T : Any> Registry<T>.getOrNull(id: Identifier): Holder.Reference<T>?

getOrThrow

open fun getOrThrow(resourceKey: ResourceKey<T>): Holder.Reference<T>

open fun getOrThrow(tagKey: TagKey<T>): HolderSet.Named<T>

getOrThrow

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

fun <T : Any> Registry<T>.getOrThrow(key: Key): Holder<T>

fun <T : Any> Registry<T>.getOrThrow(id: Identifier): Holder<T>

getRandom

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

getRandomElementOf

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

getResourceKey

open fun getResourceKey(value: T): Optional<ResourceKey<T>>

getTagOrEmpty

open fun getTagOrEmpty(key: TagKey<T>): Iterable<Holder<T>>

getTags

open fun getTags(): Stream<HolderSet.Named<T>>

getValue

open fun getValue(key: @Nullable Identifier?): @Nullable T?

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

getValue

fun <T : Any> Registry<T>.getValue(key: String?): T?

fun <T : Any> Registry<T>.getValue(key: Key?): T?

getValueForCopying

open fun getValueForCopying(resourceKey: ResourceKey<T>): Optional<T>

getValueOrThrow

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

getValueOrThrow

fun <T : Any> Registry<T>.getValueOrThrow(key: String): T

fun <T : Any> Registry<T>.getValueOrThrow(id: Identifier): T

holderByNameCodec

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

iterator

open operator fun iterator(): Iterator<T>

key

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

keys

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

keySet

open fun keySet(): Set<Identifier>

listElementIds

open fun listElementIds(): Stream<ResourceKey<T>>

listElements

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

listTagIds

open fun listTagIds(): Stream<TagKey<T>>

listTags

open fun listTags(): Stream<HolderSet.Named<T>>

prepareTagReload

open fun prepareTagReload(loadResult: TagLoader.LoadResult<T>): Registry.PendingTags<T>

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

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

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

registrationInfo

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

registryKeySet

open fun registryKeySet(): Set<ResourceKey<T>>

registryLifecycle

open fun registryLifecycle(): Lifecycle

set

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

operator fun <T : Any> WritableRegistry<T>.set(key: Key, value: T)

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

operator fun <T : Any> WritableRegistry<T>.set(key: ResourceKey<T>, value: T)

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

size

open fun size(): Int

stream

open fun stream(): Stream<T>

toHolderMap

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

toHolderSet

fun <T : Any> Iterable<TypedKey<*>>.toHolderSet(registryKey: ResourceKey<out Registry<T>>, registry: HolderGetter<T>): HolderSet<T>

toMap

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

validateWrite

open fun validateWrite(key: ResourceKey<T>)

wrapAsHolder

open fun wrapAsHolder(value: T): Holder<T>