1.21.4-common/de.rubixdev.yarrp.mixin/HolderSetCodecMixin

HolderSetCodecMixin

abstract class HolderSetCodecMixin<E> : Codec<A>

Constructors

HolderSetCodecMixin

constructor()

Properties

BOOL

val BOOL: PrimitiveCodec<Boolean>

BYTE

val BYTE: PrimitiveCodec<Byte>

BYTE_BUFFER

val BYTE_BUFFER: PrimitiveCodec<ByteBuffer>

DOUBLE

val DOUBLE: PrimitiveCodec<Double>

EMPTY

val EMPTY: MapCodec<Unit>

FLOAT

val FLOAT: PrimitiveCodec<Float>

INT

val INT: PrimitiveCodec<Integer>

INT_STREAM

val INT_STREAM: PrimitiveCodec<IntStream>

LONG

val LONG: PrimitiveCodec<Long>

LONG_STREAM

val LONG_STREAM: PrimitiveCodec<LongStream>

PASSTHROUGH

val PASSTHROUGH: Codec<Dynamic<out Any>>

SHORT

val SHORT: PrimitiveCodec<Short>

STRING

val STRING: PrimitiveCodec<String>

Functions

boxed

open fun boxed(): Decoder.Boxed<A>

checkRange

open fun <N : Number?, Comparable<N>?> checkRange(p: N, p1: N): (N) -> DataResult<N>

comap

open fun comap(p: (in B) -> out A): Encoder

comapFlatMap

open fun <S> comapFlatMap(p: (in A) -> out DataResult<out S>, p1: (in S) -> out A): Codec<S>

compoundList

open fun <K, V> compoundList(p: Codec<K>, p1: Codec<V>): Codec<List<Pair<K, V>>>

decode

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

deprecated

open fun deprecated(p: Int): Codec<A>

dispatch

open fun <E> dispatch(p: (in E) -> out A, p1: (in A) -> out MapCodec<out E>): Codec<E>

dispatchedMap

open fun <K, V> dispatchedMap(p: Codec<K>, p1: (K) -> Codec<out V>): Codec<Map<K, V>>

dispatchMap

open fun <E> dispatchMap(p: (in E) -> out A, p1: (in A) -> out MapCodec<out E>): MapCodec<E>

dispatchStable

open fun <E> dispatchStable(p: (in E) -> out A, p1: (in A) -> out MapCodec<out E>): Codec<E>

doubleRange

open fun doubleRange(p: Double, p1: Double): Codec<Double>

either

open fun <F, S> either(p: Codec<F>, p1: Codec<S>): Codec<Either<F, S>>

empty

open fun <A> empty(): MapEncoder<A>

encode

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

encodeStart

open fun <T> encodeStart(p: DynamicOps<T>, p1: A): DataResult<T>

error

open fun <A> error(p: String): Decoder<A>

open fun <A> error(p: String): Encoder<A>

fieldOf

open fun fieldOf(p: String): MapCodec<A>

open fun fieldOf(p: String): MapDecoder<A>

open fun fieldOf(p: String): MapEncoder<A>

flatComap

open fun flatComap(p: (in B) -> out DataResult<out A>): Encoder

flatComapMap

open fun <S> flatComapMap(p: (in A) -> out S, p1: (in S) -> out DataResult<out A>): Codec<S>

flatMap

open fun flatMap(p: (in A) -> out DataResult<out B>): Decoder

flatXmap

open fun <S> flatXmap(p: (in A) -> out DataResult<out S>, p1: (in S) -> out DataResult<out A>): Codec<S>

floatRange

open fun floatRange(p: Float, p1: Float): Codec<Float>

intRange

open fun intRange(p: Int, p1: Int): Codec<Integer>

lazyInitialized

open fun <A> lazyInitialized(p: Supplier<Codec<A>>): Codec<A>

lenientOptionalFieldOf

open fun lenientOptionalFieldOf(p: String): MapCodec<Optional<A>>

open fun lenientOptionalFieldOf(p: String, p1: A): MapCodec<A>

list

open fun <E> list(p: Codec<E>): Codec<List<E>>

listOf

open fun listOf(): Codec<List<A>>

map

open fun map(p: (in A) -> out B): Decoder

mapEither

open fun <F, S> mapEither(p: MapCodec<F>, p1: MapCodec<S>): MapCodec<Either<F, S>>

mapPair

open fun <F, S> mapPair(p: MapCodec<F>, p1: MapCodec<S>): MapCodec<Pair<F, S>>

mapResult

open fun mapResult(p: Codec.ResultFunction<A>): Codec<A>

open fun <A> of(p: Encoder<A>, p1: Decoder<A>): Codec<A>

open fun <A> of(p: MapEncoder<A>, p1: MapDecoder<A>): MapCodec<A>

ofBoxed

open fun <A> ofBoxed(p: Decoder.Boxed<out A>): Decoder<A>

ofSimple

open fun <A> ofSimple(p: Decoder.Simple<out A>): Decoder<A>

ofTerminal

open fun <A> ofTerminal(p: Decoder.Terminal<out A>): Decoder<A>

optionalField

open fun <F> optionalField(p: String, p1: Codec<F>, p2: Boolean): MapCodec<Optional<F>>

optionalFieldOf

open fun optionalFieldOf(p: String): MapCodec<Optional<A>>

open fun optionalFieldOf(p: String, p1: A): MapCodec<A>

orElse

open fun orElse(p: Consumer<String>, p1: A): Codec<A>

orElseGet

open fun orElseGet(p: Consumer<String>, p1: Supplier<out A>): Codec<A>

pair

open fun <F, S> pair(p: Codec<F>, p1: Codec<S>): Codec<Pair<F, S>>

parse

open fun <T> parse(p: DynamicOps<T>, p1: T): DataResult<A>

partialDispatch

open fun <E> partialDispatch(p: String, p1: (in E) -> out DataResult<out A>, p2: (in A) -> out DataResult<out MapCodec<out E>>): Codec<E>

promotePartial

open fun promotePartial(p: Consumer<String>): Codec<A>

open fun promotePartial(p: Consumer<String>): Decoder<A>

recursive

open fun <A> recursive(p: String, p1: (Codec<A>) -> Codec<A>): Codec<A>

simple

open fun simple(): Decoder.Simple<A>

simpleMap

open fun <K, V> simpleMap(p: Codec<K>, p1: Codec<V>, p2: Keyable): SimpleMapCodec<K, V>

sizeLimitedListOf

open fun sizeLimitedListOf(p: Int): Codec<List<A>>

sizeLimitedString

open fun sizeLimitedString(p: Int): Codec<String>

stable

open fun stable(): Codec<A>

string

open fun string(p: Int, p1: Int): Codec<String>

stringResolver

open fun <E> stringResolver(p: (E) -> String, p1: (String) -> E): Codec<E>

terminal

open fun terminal(): Decoder.Terminal<A>

unboundedMap

open fun <K, V> unboundedMap(p: Codec<K>, p1: Codec<V>): UnboundedMapCodec<K, V>

unit

open fun <A> unit(p: A): Codec<A>

open fun <A> unit(p: A): MapDecoder<A>

validate

open fun validate(p: (A) -> DataResult<A>): Codec<A>

withAlternative

open fun <T> withAlternative(p: Codec<T>, p1: Codec<out T>): Codec<T>

withLifecycle

open fun withLifecycle(p: Lifecycle): Codec<A>

open fun withLifecycle(p: Lifecycle): Decoder<A>

open fun withLifecycle(p: Lifecycle): Encoder<A>

xmap

open fun <S> xmap(p: (in A) -> out S, p1: (in S) -> out A): Codec<S>

xor

open fun <F, S> xor(p: Codec<F>, p1: Codec<S>): Codec<Either<F, S>>

yarrp$encodeDummySet

open fun <T> yarrp$encodeDummySet(input: HolderSet<E>, ops: DynamicOps<T>, prefix: T, cir: CallbackInfoReturnable<DataResult<T>>)