MixinSimpleRegistry

public abstract class MixinSimpleRegistry<T> extends Registry<T>

Functions

boxed

Decoder.Boxed<A> boxed()

checkRange

static Function<N, DataResult<N>> checkRange<N extends Number, Comparable<N>>(N minInclusive, N maxInclusive)

comap

Encoder comap(Function<? extends Object, ? extends A> function)

comapFlatMap

Codec<S> comapFlatMap<S>(Function<? extends Object, ? extends DataResult<? extends S>> to, Function<? extends Object, ? extends A> from)

compoundList

static Codec<List<Pair<K, V>>> compoundList<K, V>(Codec<K> keyCodec, Codec<V> elementCodec)

contains

abstract boolean contains(RegistryKey<T> key)

containsId

abstract boolean containsId(Identifier id)

decode

abstract DataResult<Pair<A, T>> decode<T>(DynamicOps<T> p, T p1)

DataResult<Pair<T, U>> decode(DynamicOps dynamicOps, U object)

deprecated

Codec<A> deprecated(int since)

dispatch

Codec<E> dispatch<E>(Function<? extends Object, ? extends A> type, Function<? extends Object, ? extends Codec<? extends E>> codec)

dispatchMap

MapCodec<E> dispatchMap<E>(Function<? extends Object, ? extends A> type, Function<? extends Object, ? extends Codec<? extends E>> codec)

dispatchStable

Codec<E> dispatchStable<E>(Function<? extends Object, ? extends A> type, Function<? extends Object, ? extends Codec<? extends E>> codec)

doubleRange

static Codec<Double> doubleRange(double minInclusive, double maxInclusive)

either

static Codec<Either<F, S>> either<F, S>(Codec<F> first, Codec<S> second)

empty

static MapEncoder<A> empty<A>()

encode

abstract DataResult<T> encode<T>(A p, DynamicOps<T> p1, T p2)

DataResult encode(T object, DynamicOps dynamicOps, U object2)

encodeStart

DataResult<T> encodeStart<T>(DynamicOps<T> ops, A input)

error

static Encoder<A> error<A>(String error)

static Decoder<A> error<A>(String error)

fieldOf

MapCodec<A> fieldOf(String name)

MapEncoder<A> fieldOf(String name)

MapDecoder<A> fieldOf(String name)

flatComap

Encoder flatComap(Function<? extends Object, ? extends DataResult<? extends A>> function)

flatComapMap

Codec<S> flatComapMap<S>(Function<? extends Object, ? extends S> to, Function<? extends Object, ? extends DataResult<? extends A>> from)

flatMap

Decoder flatMap(Function<? extends Object, ? extends DataResult<? extends B>> function)

flatXmap

Codec<S> flatXmap<S>(Function<? extends Object, ? extends DataResult<? extends S>> to, Function<? extends Object, ? extends DataResult<? extends A>> from)

floatRange

static Codec<Float> floatRange(float minInclusive, float maxInclusive)

forEach

void forEach(Consumer<? extends Object> action)

forStrings

static Keyable forStrings(Supplier<Stream<String>> keys)

get

abstract T get(RegistryKey<T> key)

getEntries

abstract Set<Map.Entry<RegistryKey<T>, T>> getEntries()

getId

abstract Identifier getId(T entry)

getIds

abstract Set<Identifier> getIds()

getKey

RegistryKey<? extends Registry<T>> getKey()

abstract Optional<RegistryKey<T>> getKey(T entry)

getLifecycle

abstract Lifecycle getLifecycle()

getOrEmpty

Optional<T> getOrEmpty(Identifier id)

getOrThrow

T getOrThrow(RegistryKey<T> key)

getRandom

abstract T getRandom(Random random)

getRawId

abstract int getRawId(T entry)

intRange

static Codec<Integer> intRange(int minInclusive, int maxInclusive)

iterator

abstract Iterator<T> iterator()

keys

abstract Stream<T> keys<T>(DynamicOps<T> p)

Stream keys(DynamicOps dynamicOps)

list

static Codec<List<E>> list<E>(Codec<E> elementCodec)

listOf

Codec<List<A>> listOf()

map

Decoder map(Function<? extends Object, ? extends B> function)

mapEither

static MapCodec<Either<F, S>> mapEither<F, S>(MapCodec<F> first, MapCodec<S> second)

mapPair

static MapCodec<Pair<F, S>> mapPair<F, S>(MapCodec<F> first, MapCodec<S> second)

mapResult

Codec<A> mapResult(Codec.ResultFunction<A> function)

static Codec<A> of<A>(Encoder<A> encoder, Decoder<A> decoder)

static MapCodec<A> of<A>(MapEncoder<A> encoder, MapDecoder<A> decoder)

ofBoxed

static Decoder<A> ofBoxed<A>(Decoder.Boxed<? extends A> boxed)

ofSimple

static Decoder<A> ofSimple<A>(Decoder.Simple<? extends A> simple)

ofTerminal

static Decoder<A> ofTerminal<A>(Decoder.Terminal<? extends A> terminal)

optionalField

static MapCodec<Optional<F>> optionalField<F>(String name, Codec<F> elementCodec)

optionalFieldOf

MapCodec<Optional<A>> optionalFieldOf(String name)

MapCodec<A> optionalFieldOf(String name, A defaultValue)

orElse

Codec<A> orElse(Consumer<String> onError, A value)

orElseGet

Codec<A> orElseGet(Consumer<String> onError, Supplier<? extends A> value)

pair

static Codec<Pair<F, S>> pair<F, S>(Codec<F> first, Codec<S> second)

parse

DataResult<A> parse<T>(DynamicOps<T> ops, T input)

partialDispatch

Codec<E> partialDispatch<E>(String typeKey, Function<? extends Object, ? extends DataResult<? extends A>> type, Function<? extends Object, ? extends DataResult<? extends Codec<? extends E>>> codec)

promotePartial

Codec<A> promotePartial(Consumer<String> onError)

Decoder<A> promotePartial(Consumer<String> onError)

static T register<T>(Registry<? extends Object> registry, String id, T entry)

simple

Decoder.Simple<A> simple()

simpleMap

static SimpleMapCodec<K, V> simpleMap<K, V>(Codec<K> keyCodec, Codec<V> elementCodec, Keyable keys)

spliterator

Spliterator<T> spliterator()

stable

Codec<A> stable()

stream

Stream<T> stream()

terminal

Decoder.Terminal<A> terminal()

toString

String toString()

unboundedMap

static UnboundedMapCodec<K, V> unboundedMap<K, V>(Codec<K> keyCodec, Codec<V> elementCodec)

unit

static Codec<A> unit<A>(A defaultValue)

static MapDecoder<A> unit<A>(A instance)

validate

static void validate<T extends MutableRegistry<? extends Object>>(MutableRegistry<T> registry)

withLifecycle

Codec<A> withLifecycle(Lifecycle lifecycle)

Encoder<A> withLifecycle(Lifecycle lifecycle)

Decoder<A> withLifecycle(Lifecycle lifecycle)

xmap

Codec<S> xmap<S>(Function<? extends Object, ? extends S> to, Function<? extends Object, ? extends A> from)

Sources

jvm source