Codec (datafixerupper 4.0.0-SNAPSHOT API)

Type Parameters:

A - The type this Codec serializes and deserializes.

All Superinterfaces:

Decoder<A>, Encoder<A>

All Known Subinterfaces:

PrimitiveCodec<A>

All Known Implementing Classes:

CompoundListCodec, EitherCodec, ListCodec, MapCodec.MapCodecCodec, PairCodec, UnboundedMapCodec
```
public interface Codec<A>
extends Encoder<A>, Decoder<A>
```
A combined Decoder and Encoder.
A Codec handles transformation of a specific type to and from a provided serialized form. Codecs encapsulate both the behaviors of an encoder and those of a decoder in the same object.
Implementations of Codec are immutable once created. The methods defined in this interface never mutate the codec in a way visible to the outside.

Implementation Requirements:

An implementation must include, at a minimum, definitions of the Encoder.encode(Object, DynamicOps, Object) and Decoder.decode(DynamicOps, Object) methods.

Implementation Note:

The default methods in this interface that return codecs or map codecs wrap this codec without adding any debugging context. These methods should be overridden if deeply nested codecs are undesirable or additional debugging context is desired.

See Also:

MapCodec

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static interface Codec.ResultFunction<A>
A unary operator applied on the result obtained from decoding or encoding from a Codec.
- Nested classes/interfaces inherited from interface com.mojang.serialization.Decoder
  Decoder.Boxed<A>, Decoder.Simple<A>, Decoder.Terminal<A>

Nested Classes
Modifier and Type	Interface and Description
`static interface`	`Codec.ResultFunction<A>` A unary operator applied on the result obtained from decoding or encoding from a `Codec`.

Field Summary

Fields
Modifier and Type	Field and Description
`static PrimitiveCodec<Boolean>`	`BOOL` A `PrimitiveCodec` for the type `boolean`.
`static PrimitiveCodec<Byte>`	`BYTE` A `PrimitiveCodec` for the type `byte`.
`static PrimitiveCodec<ByteBuffer>`	`BYTE_BUFFER` A `PrimitiveCodec` for the type `ByteBuffer` (a byte sequence).
`static PrimitiveCodec<Double>`	`DOUBLE` A `PrimitiveCodec` for the type `double`.
`static MapCodec<Unit>`	`EMPTY` A `MapCodec` that performs no encoding nor decoding.
`static PrimitiveCodec<Float>`	`FLOAT` A `PrimitiveCodec` for the type `float`.
`static PrimitiveCodec<Integer>`	`INT` A `PrimitiveCodec` for the type `int`.
`static PrimitiveCodec<IntStream>`	`INT_STREAM` A `PrimitiveCodec` for the type `IntStream` (an int sequence).
`static PrimitiveCodec<Long>`	`LONG` A `PrimitiveCodec` for the type `long`.
`static PrimitiveCodec<LongStream>`	`LONG_STREAM` A `PrimitiveCodec` for the type `LongStream` (a long sequence).
`static Codec<Dynamic<?>>`	`PASSTHROUGH` A codec that "passes through" serialized forms unchanged.
`static PrimitiveCodec<Short>`	`SHORT` A `PrimitiveCodec` for the type `short`.
`static PrimitiveCodec<String>`	`STRING` A `PrimitiveCodec` for the type `String`.

Method Summary

All Methods Static Methods Instance Methods Default Methods
Modifier and Type	Method and Description
`static <N extends Number & Comparable<N>> (N) -> DataResult<N>`	`checkRange(N minInclusive, N maxInclusive)`
`default <S> Codec<S>`	`comapFlatMap((? super A) -> ? extends DataResult<? extends S> to, (? super S) -> ? extends A from)` Transforms this codec into another codec using the given invertible partial function.
`static <K,V> Codec<List<(K,V)>>`	`compoundList(Codec<K> keyCodec, Codec<V> elementCodec)` Creates a codec for a list of key-value pairs from codecs for the element types.
`default Codec<A>`	`deprecated(int since)` Returns an equivalent `Codec` with a deprecated lifecycle.
`default <E> Codec<E>`	`dispatch((? super E) -> ? extends A type, (? super A) -> ? extends Codec<? extends E> codec)` Returns a `Codec` that uses a default type key extracted using this codec to polymorphically dispatch against a complete set of supported subtypes.
`default <E> Codec<E>`	`dispatch(String typeKey, (? super E) -> ? extends A type, (? super A) -> ? extends Codec<? extends E> codec)` Returns a `Codec` that uses a type key extracted using this codec to polymorphically dispatch against a complete set of supported subtypes.
`default <E> MapCodec<E>`	`dispatchMap((? super E) -> ? extends A type, (? super A) -> ? extends Codec<? extends E> codec)` Returns a `MapCodec` that uses a default type key extracted using this codec to polymorphically dispatch against a complete set of supported subtypes.
`default <E> MapCodec<E>`	`dispatchMap(String typeKey, (? super E) -> ? extends A type, (? super A) -> ? extends Codec<? extends E> codec)` Returns a `MapCodec` that uses a type key extracted using this codec to polymorphically dispatch against a complete set of supported subtypes.
`default <E> Codec<E>`	`dispatchStable((? super E) -> ? extends A type, (? super A) -> ? extends Codec<? extends E> codec)` Returns a `Codec` that uses a default type key extracted using this codec to polymorphically dispatch against a complete set of supported subtypes.
`static Codec<Double>`	`doubleRange(double minInclusive, double maxInclusive)`
`static <F,S> Codec<(F\|S)>`	`either(Codec<F> first, Codec<S> second)` Creates a codec for an `Either` from codecs for its elements.
`default MapCodec<A>`	`fieldOf(String name)` Returns a `MapCodec` that encodes and decodes objects in a record under a field with the given name.
`default <S> Codec<S>`	`flatComapMap((? super A) -> ? extends S to, (? super S) -> ? extends DataResult<? extends A> from)` Transforms this codec into another codec using the given partially invertible function.
`default <S> Codec<S>`	`flatXmap((? super A) -> ? extends DataResult<? extends S> to, (? super S) -> ? extends DataResult<? extends A> from)` Transforms this codec into another codec using the given partially invertible partial function.
`static Codec<Float>`	`floatRange(float minInclusive, float maxInclusive)`
`static Codec<Integer>`	`intRange(int minInclusive, int maxInclusive)`
`static <E> Codec<List<E>>`	`list(Codec<E> elementCodec)` Creates a codec for a `List` from a codec for the element type.
`default Codec<List<A>>`	`listOf()` Returns a codec for a `List` of elements defined by this codec.
`static <F,S> MapCodec<(F\|S)>`	`mapEither(MapCodec<F> first, MapCodec<S> second)` Creates a map codec for an `Either` from map codecs for its elements.
`static <F,S> MapCodec<(F,S)>`	`mapPair(MapCodec<F> first, MapCodec<S> second)` Creates a map codec for a `Pair` from map codecs for its elements.
`default Codec<A>`	`mapResult(Codec.ResultFunction<A> function)` Transforms the `DataResult` produced by this code's decode and encode methods.
`static <A> Codec<A>`	`of(Encoder<A> encoder, Decoder<A> decoder)` Combines an `Encoder` and a `Decoder` into a `Codec`.
`static <A> Codec<A>`	`of(Encoder<A> encoder, Decoder<A> decoder, String name)` Combines an `Encoder` and a `Decoder` into a named `Codec`.
`static <A> MapCodec<A>`	`of(MapEncoder<A> encoder, MapDecoder<A> decoder)` Combines a `MapEncoder` and a `MapDecoder` into a `MapCodec`.
`static <A> MapCodec<A>`	`of(MapEncoder<A> encoder, MapDecoder<A> decoder, by-name String name)` Combines a `MapEncoder` and a `MapDecoder` into a named `MapCodec`.
`static <F> MapCodec<Optional<F>>`	`optionalField(String name, Codec<F> elementCodec)` Creates a `MapCodec` that encodes and decodes an optional record field.
`default MapCodec<Optional<A>>`	`optionalFieldOf(String name)` Returns a `MapCodec` that encodes and decodes objects the may optionally appear in a record.
`default MapCodec<A>`	`optionalFieldOf(String name, A defaultValue)` Returns a `MapCodec` that encodes and decodes objects that may optionally appear in a record.
`default MapCodec<A>`	`optionalFieldOf(String name, A defaultValue, Lifecycle lifecycleOfDefault)` Returns a `MapCodec` that encodes and decodes objects that may optionally appear in a record, and additionally allows the caller to provide a lifecycle for the default value.
`default MapCodec<A>`	`optionalFieldOf(String name, Lifecycle fieldLifecycle, A defaultValue, Lifecycle lifecycleOfDefault)` Returns a `MapCodec` that encodes and decodes objects that may optionally appear in a record, and additionally allows the caller to provide lifecycles for the present field values and the default value.
`default Codec<A>`	`orElse(A value)` Provides a default value for decoding in case of error.
`default Codec<A>`	`orElse((String) -> void onError, A value)` Provides a default value for decoding in case of error, and runs the given callback on error.
`default Codec<A>`	`orElse((String) -> String onError, A value)` Provides a default value for decoding in case of error, and transforms the error.
`default Codec<A>`	`orElseGet((String) -> void onError, by-name ? extends A value)` Provides a default value for decoding in case of error, and runs the given callback on error.
`default Codec<A>`	`orElseGet(by-name ? extends A value)` Provides a default value for decoding in case of error.
`default Codec<A>`	`orElseGet((String) -> String onError, by-name ? extends A value)` Provides a default value for decoding in case of error, and transforms the error.
`static <F,S> Codec<(F,S)>`	`pair(Codec<F> first, Codec<S> second)` Creates a codec for a `Pair` from codecs for its elements.
`default <E> Codec<E>`	`partialDispatch(String typeKey, (? super E) -> ? extends DataResult<? extends A> type, (? super A) -> ? extends DataResult<? extends Codec<? extends E>> codec)` Returns a `Codec` that uses a type key extracted using this codec to polymorphically dispatch against a partial set of supported subtypes.
`default Codec<A>`	`promotePartial((String) -> void onError)` Returns a `Decoder` that returns the partial decoded result in this decoder returns an error.
`static <K,V> SimpleMapCodec<K,V>`	`simpleMap(Codec<K> keyCodec, Codec<V> elementCodec, Keyable keys)` Creates a map codec for a `Map` with a fixed key set.
`default Codec<A>`	`stable()` Returns an equivalent `Codec` with the stable lifecycle.
`static <K,V> UnboundedMapCodec<K,V>`	`unboundedMap(Codec<K> keyCodec, Codec<V> elementCodec)` Creates a map codec for a `Map` with arbitrary keys.
`static <A> Codec<A>`	`unit(A defaultValue)` Returns a codec that always decodes the given value and always encodes an empty value.
`static <A> Codec<A>`	`unit(by-name A defaultValue)` Returns a codec that always decodes a supplied value and always encodes an empty value.
`default Codec<A>`	`withLifecycle(Lifecycle lifecycle)` Sets the `Lifecycle` for any result data this codec produces.
`default <S> Codec<S>`	`xmap((? super A) -> ? extends S to, (? super S) -> ? extends A from)` Transforms this codec into another codec using the given invertible mapping functions.

Methods inherited from interface com.mojang.serialization.Encoder
comap, empty, encode, encodeStart, error, flatComap

Methods inherited from interface com.mojang.serialization.Decoder
boxed, decode, decode, error, flatMap, map, ofBoxed, ofSimple, ofTerminal, parse, parse, simple, terminal

- Field Detail
  - BOOL
```
static final PrimitiveCodec<Boolean> BOOL
```
    A PrimitiveCodec for the type boolean.
  - BYTE
```
static final PrimitiveCodec<Byte> BYTE
```
    A PrimitiveCodec for the type byte.
  - SHORT
```
static final PrimitiveCodec<Short> SHORT
```
    A PrimitiveCodec for the type short.
  - INT
```
static final PrimitiveCodec<Integer> INT
```
    A PrimitiveCodec for the type int.
  - LONG
```
static final PrimitiveCodec<Long> LONG
```
    A PrimitiveCodec for the type long.
  - FLOAT
```
static final PrimitiveCodec<Float> FLOAT
```
    A PrimitiveCodec for the type float.
  - DOUBLE
```
static final PrimitiveCodec<Double> DOUBLE
```
    A PrimitiveCodec for the type double.
  - STRING
```
static final PrimitiveCodec<String> STRING
```
    A PrimitiveCodec for the type String.
  - BYTE_BUFFER
```
static final PrimitiveCodec<ByteBuffer> BYTE_BUFFER
```
    A PrimitiveCodec for the type ByteBuffer (a byte sequence).
  - INT_STREAM
```
static final PrimitiveCodec<IntStream> INT_STREAM
```
    A PrimitiveCodec for the type IntStream (an int sequence).
  - LONG_STREAM
```
static final PrimitiveCodec<LongStream> LONG_STREAM
```
    A PrimitiveCodec for the type LongStream (a long sequence).
  - PASSTHROUGH
```
static final Codec<Dynamic<?>> PASSTHROUGH
```
    A codec that "passes through" serialized forms unchanged.
  - EMPTY
```
static final MapCodec<Unit> EMPTY
```
    A MapCodec that performs no encoding nor decoding.
- Method Detail
  - withLifecycle
```
default Codec<A> withLifecycle(Lifecycle lifecycle)
```
    Sets the Lifecycle for any result data this codec produces.
    
    Specified by:
    
    withLifecycle in interface Decoder<A>
    
    Specified by:
    
    withLifecycle in interface Encoder<A>
    
    Implementation Requirements:
    
    The default implementation returns another Codec that wraps this codec.
    
    Parameters:
    
    lifecycle - the lifecycle to use.
    
    Returns:
    
    An codec equivalent to this codec but with the given lifecycle.
    
    See Also:
    
    Lifecycle
  - stable
```
default Codec<A> stable()
```
    Returns an equivalent Codec with the stable lifecycle.
    
    See Also:
    
    Lifecycle.stable()
  - deprecated
```
default Codec<A> deprecated(int since)
```
    Returns an equivalent Codec with a deprecated lifecycle.
    
    Parameters:
    
    since - The deprecation version.
    
    See Also:
    
    Lifecycle.deprecated(int)
  - of
```
static <A> Codec<A> of(Encoder<A> encoder,
                       Decoder<A> decoder)
```
    Combines an Encoder and a Decoder into a Codec.
    
    Type Parameters:
    
    A - The type the returned codec operates on.
    
    Parameters:
    
    encoder - The Encoder defining the returned codec.
    
    decoder - The Decoder defining the returned codec.
    
    Returns:
    
    A codec that combines the given encoder and decoder.
  - of
```
static <A> Codec<A> of(Encoder<A> encoder,
                       Decoder<A> decoder,
                       String name)
```
    Combines an Encoder and a Decoder into a named Codec.
    
    Type Parameters:
    
    A - The type the returned codec operates on.
    
    Parameters:
    
    encoder - The Encoder defining the returned codec.
    
    decoder - The Decoder defining the returned codec.
    
    name - The name given in the string representation of the returned codec.
    
    Returns:
    
    A codec that combines the given encoder and decoder.
    
    See Also:
    
    of(Encoder, Decoder)
  - of
```
static <A> MapCodec<A> of(MapEncoder<A> encoder,
                          MapDecoder<A> decoder)
```
    Combines a MapEncoder and a MapDecoder into a MapCodec.
    
    Type Parameters:
    
    A - The type the returned codec operates on.
    
    Parameters:
    
    encoder - The MapEncoder defining the returned MapCodec.
    
    decoder - The MapDecoder defining the returned MapCodec.
    
    Returns:
    
    A MapCodec combining the given encoder and decoder.
  - of
```
static <A> MapCodec<A> of(MapEncoder<A> encoder,
                          MapDecoder<A> decoder,
                          by-name String name)
```
    Combines a MapEncoder and a MapDecoder into a named MapCodec. The key stream of the returned codec is the concatenation of the key stream of the encoder and decoder.
    
    Type Parameters:
    
    A - The type the returned codec operates on.
    
    Parameters:
    
    encoder - The MapEncoder defining the returned MapCodec.
    
    decoder - The MapDecoder defining the returned MapCodec.
    
    name - The name given in the string representation of the returned MapCodec.
    
    Returns:
    
    A MapCodec combining the given encoder and decoder.
    
    See Also:
    
    of(MapEncoder, MapDecoder)
  - pair
```
static <F,S> Codec<(F,S)> pair(Codec<F> first,
                               Codec<S> second)
```
    Creates a codec for a Pair from codecs for its elements.
    
    Type Parameters:
    
    F - The first element type.
    
    S - The second element type.
    
    Parameters:
    
    first - A codec for the first element type.
    
    second - A codec for the second element type.
    
    Returns:
    
    A codec for a Pair of the element types.
  - either
```
static <F,S> Codec<(F|S)> either(Codec<F> first,
                                 Codec<S> second)
```
    Creates a codec for an Either from codecs for its elements.
    
    Type Parameters:
    
    F - The first element type.
    
    S - The second element type.
    
    Parameters:
    
    first - A codec for the first element type.
    
    second - A codec for the second element type.
    
    Returns:
    
    A codec for an Either of the element types.
  - mapPair
```
static <F,S> MapCodec<(F,S)> mapPair(MapCodec<F> first,
                                     MapCodec<S> second)
```
    Creates a map codec for a Pair from map codecs for its elements.
    
    Type Parameters:
    
    F - The first element type.
    
    S - The second element type.
    
    Parameters:
    
    first - A codec for the first element type.
    
    second - A codec for the second element type.
    
    Returns:
    
    A codec for a Pair of the element types.
  - mapEither
```
static <F,S> MapCodec<(F|S)> mapEither(MapCodec<F> first,
                                       MapCodec<S> second)
```
    Creates a map codec for an Either from map codecs for its elements.
    
    Type Parameters:
    
    F - The first element type.
    
    S - The second element type.
    
    Parameters:
    
    first - A codec for the first element type.
    
    second - A codec for the second element type.
    
    Returns:
    
    A codec for an Either of the element types.
  - list
```
static <E> Codec<List<E>> list(Codec<E> elementCodec)
```
    Creates a codec for a List from a codec for the element type.
    
    Type Parameters:
    
    E - The element type of the list.
    
    Parameters:
    
    elementCodec - A codec for the element type of the list.
    
    Returns:
    
    A codec for a List of the element type.
    
    See Also:
    
    listOf()
  - compoundList
```
static <K,V> Codec<List<(K,V)>> compoundList(Codec<K> keyCodec,
                                             Codec<V> elementCodec)
```
    Creates a codec for a list of key-value pairs from codecs for the element types.
    
    Implementation Note:
    
    This implementation is likely more efficient than calling pair(Codec, Codec) and list(Codec) in sequence.
    
    Type Parameters:
    
    K - The key type.
    
    V - The element type.
    
    Parameters:
    
    keyCodec - A codec for the key type.
    
    elementCodec - A codec for the element type.
    
    Returns:
    
    A codec for a list of key-value pairs.
    
    See Also:
    
    pair(Codec, Codec), list(Codec)
  - simpleMap
```
static <K,V> SimpleMapCodec<K,V> simpleMap(Codec<K> keyCodec,
                                           Codec<V> elementCodec,
                                           Keyable keys)
```
    Creates a map codec for a Map with a fixed key set.
    For creating a map codec with an unbounded key set, see unboundedMap(Codec, Codec).
    
    Type Parameters:
    
    K - The key type.
    
    V - The element type.
    
    Parameters:
    
    keyCodec - A codec for the key type.
    
    elementCodec - A codec for the element type.
    
    keys - A Keyable defining the set of allowed keys.
    
    Returns:
    
    A MapCodec for a map with fixed keys.
  - unboundedMap
```
static <K,V> UnboundedMapCodec<K,V> unboundedMap(Codec<K> keyCodec,
                                                 Codec<V> elementCodec)
```
    Creates a map codec for a Map with arbitrary keys.
    For creating a map codec with a fixed key set, see simpleMap(Codec, Codec, Keyable).
    
    Type Parameters:
    
    K - The key type.
    
    V - The element type.
    
    Parameters:
    
    keyCodec - A codec for the key type.
    
    elementCodec - A codec for the element type.
    
    Returns:
    
    A MapCodec for a map with arbitrary keys.
  - optionalField
```
static <F> MapCodec<Optional<F>> optionalField(String name,
                                               Codec<F> elementCodec)
```
    Creates a MapCodec that encodes and decodes an optional record field. Absent Optional values will not be serialized and visa-versa.
    
    Type Parameters:
    
    F - The element type.
    
    Parameters:
    
    name - The name of the field.
    
    elementCodec - A codec for the element type.
    
    Returns:
    
    A map codec for the optional field name.
    
    See Also:
    
    optionalFieldOf(String), fieldOf(String)
  - listOf
```
default Codec<List<A>> listOf()
```
    Returns a codec for a List of elements defined by this codec.
    
    Implementation Requirements:
    
    The default implementation returns list(this).
  - xmap
```
default <S> Codec<S> xmap((? super A) -> ? extends S to,
                          (? super S) -> ? extends A from)
```
    Transforms this codec into another codec using the given invertible mapping functions.
    This method performs a map operation on both Decoder and Encoder.
    
    Implementation Requirements:
    
    The default implementation calls Encoder.comap(Function) and Decoder.map(Function) on this codec.
    
    Type Parameters:
    
    S - The new type.
    
    Parameters:
    
    to - A function from this codec's type to the new type.
    
    from - A function from the new type to this codec's type.
    
    Returns:
    
    A codec for the new type.
    
    See Also:
    
    Decoder.map(Function), Encoder.comap(Function)
  - comapFlatMap
```
default <S> Codec<S> comapFlatMap((? super A) -> ? extends DataResult<? extends S> to,
                                  (? super S) -> ? extends A from)
```
    Transforms this codec into another codec using the given invertible partial function.
    This method performs a flatMap operation on Decoder and a map operation on Encoder.
    
    Implementation Requirements:
    
    The default implementation calls Encoder.comap(Function) and Decoder.flatMap(Function).
    
    Type Parameters:
    
    S - The new type.
    
    Parameters:
    
    to - A partial function form this codec's type to the new type. The value and any errors are wrapped in a DataResult.
    
    from - A function from the new type to this codec's type.
    
    Returns:
    
    A codec for the new type.
    
    See Also:
    
    Decoder.flatMap(Function), Encoder.comap(Function)
  - flatComapMap
```
default <S> Codec<S> flatComapMap((? super A) -> ? extends S to,
                                  (? super S) -> ? extends DataResult<? extends A> from)
```
    Transforms this codec into another codec using the given partially invertible function.
    This method performs a map operation on Decoder and a flatMap operation on Encoder.
    
    Implementation Requirements:
    
    The default implementation calls Encoder.flatComap(Function) and Decoder.map(Function).
    
    Type Parameters:
    
    S - The new type.
    
    Parameters:
    
    to - A function form this codec's type to the new type.
    
    from - A partial function from the new type to this codec's type. The value and any errors are wrapped in a DataResult.
    
    Returns:
    
    A codec for the new type.
    
    See Also:
    
    Decoder.map(Function), Encoder.flatComap(Function)
  - flatXmap
```
default <S> Codec<S> flatXmap((? super A) -> ? extends DataResult<? extends S> to,
                              (? super S) -> ? extends DataResult<? extends A> from)
```
    Transforms this codec into another codec using the given partially invertible partial function.
    This method performs a flatMap operation on both Decoder and Encoder.
    
    Implementation Requirements:
    
    The default implementation calls Encoder.flatComap(Function) and Decoder.flatMap(Function).
    
    Type Parameters:
    
    S - The new type.
    
    Parameters:
    
    to - A partial function form this codec's type to the new type.The value and any errors are wrapped in a DataResult.
    
    from - A partial function from the new type to this codec's type. The value and any errors are wrapped in a DataResult.
    
    Returns:
    
    A codec for the new type.
    
    See Also:
    
    Decoder.flatMap(Function), Encoder.flatComap(Function)
  - fieldOf
```
default MapCodec<A> fieldOf(String name)
```
    Returns a MapCodec that encodes and decodes objects in a record under a field with the given name. The returned MapCodec may be used to serialize and deserialize many different fields, all using different codecs, from a single record.
    
    Specified by:
    
    fieldOf in interface Decoder<A>
    
    Specified by:
    
    fieldOf in interface Encoder<A>
    
    Implementation Requirements:
    
    The default implementation calls the superinterface default implementations Encoder.fieldOf(String) and Decoder.fieldOf(String) and combines them into a MapCodec.
    
    Parameters:
    
    name - The field to encode and decode objects from.
    
    Returns:
    
    A MapCodec that performs the same operations as this codec, but takes the serialized value from a record under the given field.
    
    See Also:
    
    RecordCodecBuilder, MapLike, MapCodec.of(MapEncoder, MapDecoder)
  - optionalFieldOf
```
default MapCodec<Optional<A>> optionalFieldOf(String name)
```
    Returns a MapCodec that encodes and decodes objects the may optionally appear in a record. Absent Optional values will not be serialized to the record, and visa-versa.
    
    Implementation Requirements:
    
    The default implementation returns optionalField(name, this).
    
    Parameters:
    
    name - The field to encode and decode objects from.
    
    Returns:
    
    A MapCodec that performs the same operations as this codec, but taking the optional value from a record field.
    
    See Also:
    
    optionalField(String, Codec), fieldOf(String), optionalFieldOf(String, Object)
  - optionalFieldOf
```
default MapCodec<A> optionalFieldOf(String name,
                                    A defaultValue)
```
    Returns a MapCodec that encodes and decodes objects that may optionally appear in a record. Absent values will be decoded as the default value, and the default value will be encoded as absent.
    
    Implementation Requirements:
    
    The default implementation calls optionalField(String, Codec), then maps absent optionals to the default value.
    
    Parameters:
    
    name - The field to encode and decode objects from.
    
    defaultValue - The default value to use if the value is absent in the serialized form.
    
    Returns:
    
    A MapCodec that performs operations on an optional record field.
  - optionalFieldOf
```
default MapCodec<A> optionalFieldOf(String name,
                                    A defaultValue,
                                    Lifecycle lifecycleOfDefault)
```
    Returns a MapCodec that encodes and decodes objects that may optionally appear in a record, and additionally allows the caller to provide a lifecycle for the default value. Absent values will be decoded as the default value, and the default value will be encoded as absent.
    
    Implementation Requirements:
    
    The default implementation calls optionalFieldOf(String, Lifecycle, Object, Lifecycle) with a field lifecycle of Lifecycle.experimental().
    
    Parameters:
    
    name - The field to encode and decode objects from.
    
    defaultValue - The default value to use if the value is absent in the serialized form.
    
    lifecycleOfDefault - The lifecycle of the default value.
    
    Returns:
    
    A MapCodec that performs operations on an optional record field.
    
    See Also:
    
    optionalFieldOf(String, Object)
  - optionalFieldOf
```
default MapCodec<A> optionalFieldOf(String name,
                                    Lifecycle fieldLifecycle,
                                    A defaultValue,
                                    Lifecycle lifecycleOfDefault)
```
    Returns a MapCodec that encodes and decodes objects that may optionally appear in a record, and additionally allows the caller to provide lifecycles for the present field values and the default value. Absent values will be decoded as the default value, and the default value will be encoded as absent.
    
    Implementation Requirements:
    
    The default implementation calls optionalField(String, Codec), then maps absent optionals to the default value.
    
    Parameters:
    
    name - The field to encode and decode objects from.
    
    defaultValue - The default value to use if the value is absent in the serialized form.
    
    fieldLifecycle - The lifecycle of the encoded or decoded fields.
    
    lifecycleOfDefault - The lifecycle of the default value.
    
    Returns:
    
    A MapCodec that performs operations on an optional record field.
    
    See Also:
    
    optionalFieldOf(String, Object)
  - mapResult
```
default Codec<A> mapResult(Codec.ResultFunction<A> function)
```
    Transforms the DataResult produced by this code's decode and encode methods.
    
    Implementation Requirements:
    
    The default implementation returns a new codec that wraps this codec.
    
    Parameters:
    
    function - The function to run on the produced DataResult.
    
    Returns:
    
    A codec that runs the given function after decoding or encoding.
    
    See Also:
    
    Decoder.decode(DynamicOps, Object), Encoder.encode(Object, DynamicOps, Object)
  - orElse
```
default Codec<A> orElse((String) -> void onError,
                        A value)
```
    Provides a default value for decoding in case of error, and runs the given callback on error.
    
    Implementation Requirements:
    
    The default implementation calls orElse(UnaryOperator, Object), passing an error function that returns its input after calling onError.
    
    Parameters:
    
    onError - The callback to run if decoding or encoding fails.
    
    value - The default value to return if decoding fails.
    
    Returns:
    
    A codec that implements the error handling behavior.
    
    See Also:
    
    orElse(Object)
  - orElse
```
default Codec<A> orElse((String) -> String onError,
                        A value)
```
    Provides a default value for decoding in case of error, and transforms the error.
    
    Implementation Requirements:
    
    The default implementation calls mapResult(ResultFunction) with a Codec.ResultFunction that maps the results and applies the error function.
    
    Parameters:
    
    onError - A function that transforms an error if one is returned.
    
    value - The default value to return if decoding fails.
    
    Returns:
    
    A codec that implements the error handling behavior.
    
    See Also:
    
    Codec.ResultFunction
  - orElseGet
```
default Codec<A> orElseGet((String) -> void onError,
                           by-name ? extends A value)
```
    Provides a default value for decoding in case of error, and runs the given callback on error.
    
    Implementation Requirements:
    
    The default implementation calls orElseGet(UnaryOperator, Supplier), passing an error function that returns its input after calling onError.
    
    Parameters:
    
    onError - The callback to run if decoding or encoding fails.
    
    value - A supplier of default values to return if decoding fails.
    
    Returns:
    
    A codec that implements the error handling behavior.
  - orElseGet
```
default Codec<A> orElseGet((String) -> String onError,
                           by-name ? extends A value)
```
    Provides a default value for decoding in case of error, and transforms the error.
    
    Implementation Requirements:
    
    The default implementation calls mapResult(ResultFunction) with a Codec.ResultFunction that maps the results and applies the error function.
    
    Parameters:
    
    onError - A function that transforms an error if one is returned.
    
    value - A supplier of default values to return if decoding fails.
    
    Returns:
    
    A codec that implements the error handling behavior.
    
    See Also:
    
    Codec.ResultFunction
  - orElse
```
default Codec<A> orElse(A value)
```
    Provides a default value for decoding in case of error.
    
    Implementation Requirements:
    
    The default implementation calls mapResult(ResultFunction) with a Codec.ResultFunction that supplies the default value if this codec cannot decode.
    
    Parameters:
    
    value - The default value to return if decoding fails.
    
    Returns:
    
    A codec that returns the default value if decoding fails.
  - orElseGet
```
default Codec<A> orElseGet(by-name ? extends A value)
```
    Provides a default value for decoding in case of error.
    
    Implementation Requirements:
    
    The default implementation calls mapResult(ResultFunction) with a Codec.ResultFunction that supplies the default value if this codec cannot decode.
    
    Parameters:
    
    value - A supplier of default values to return if decoding fails.
    
    Returns:
    
    A codec that returns the default value if decoding fails.
  - promotePartial
```
default Codec<A> promotePartial((String) -> void onError)
```
    Description copied from interface: Decoder
    
    Returns a Decoder that returns the partial decoded result in this decoder returns an error.
    
    Specified by:
    
    promotePartial in interface Decoder<A>
    
    Parameters:
    
    onError - A callback to run if an error occurs when decoding. The function receives the error message as its argument.
    
    Returns:
    
    A Decoder that promotes any partial result to a successful decoded result.
    
    See Also:
    
    DataResult.promotePartial(Consumer)
  - unit
```
static <A> Codec<A> unit(A defaultValue)
```
    Returns a codec that always decodes the given value and always encodes an empty value.
    
    Specified by:
    
    unit in interface Decoder<A>
    
    Type Parameters:
    
    A - The type of the value.
    
    Parameters:
    
    defaultValue - The value to decode.
    
    Returns:
    
    A codec that always decodes the given value.
    
    See Also:
    
    Decoder.unit(Supplier)
  - unit
```
static <A> Codec<A> unit(by-name A defaultValue)
```
    Returns a codec that always decodes a supplied value and always encodes an empty value.
    
    Specified by:
    
    unit in interface Decoder<A>
    
    Type Parameters:
    
    A - The type of the value.
    
    Parameters:
    
    defaultValue - A supplier of the value to decode.
    
    Returns:
    
    A codec that always decodes the given value.
    
    See Also:
    
    Decoder.unit(Supplier)
  - dispatch
```
default <E> Codec<E> dispatch((? super E) -> ? extends A type,
                              (? super A) -> ? extends Codec<? extends E> codec)
```
    Returns a Codec that uses a default type key extracted using this codec to polymorphically dispatch against a complete set of supported subtypes. This method can be used to implement encoding and decoding over algebraic types or sealed class hierarchies which may require different codecs for each subtype.
    This method is equivalent to dispatch("type", type, codec).
    Warning: This method is unsound. Care must be taken that the codecs returned by codec actually accept the correct subtype, and not an incidental subtype thereof. Heap pollution may occur when using this method unless the programmer checks that the correct types are inferred or specified.
    
    Implementation Requirements:
    
    The default implementation calls dispatch(String, Function, Function) with the type key "type".
    
    Type Parameters:
    
    E - The polymorphic object type.
    
    Parameters:
    
    type - A function that extracts the type key from the a polymorphic value.
    
    codec - A function that produces a codec for a subtype corresponding to the provided type key.
    
    Returns:
    
    A codec that operates on the polymorphic object type.
    
    See Also:
    
    dispatchStable(Function, Function)
  - dispatch
```
default <E> Codec<E> dispatch(String typeKey,
                              (? super E) -> ? extends A type,
                              (? super A) -> ? extends Codec<? extends E> codec)
```
    Returns a Codec that uses a type key extracted using this codec to polymorphically dispatch against a complete set of supported subtypes. This method can be used to implement encoding and decoding over algebraic types or sealed class hierarchies which may require different codecs for each subtype.
    Warning: This method is unsound. Care must be taken that the codecs returned by codec actually accept the correct subtype, and not an incidental subtype thereof. Heap pollution may occur when using this method unless the programmer checks that the correct types are inferred or specified.
    
    Implementation Requirements:
    
    The default implementation calls partialDispatch(String, Function, Function), with the type and codec functions always returning a success.
    
    Type Parameters:
    
    E - The polymorphic object type.
    
    Parameters:
    
    typeKey - The field in the record that the serialized type key is stored under.
    
    type - A partial function that extracts the type key from the a polymorphic value.
    
    codec - A function that produces a codec for a subtype corresponding to the provided type key.
    
    Returns:
    
    A codec that operates on the polymorphic object type.
    
    See Also:
    
    dispatch(Function, Function)
  - dispatchStable
```
default <E> Codec<E> dispatchStable((? super E) -> ? extends A type,
                                    (? super A) -> ? extends Codec<? extends E> codec)
```
    Returns a Codec that uses a default type key extracted using this codec to polymorphically dispatch against a complete set of supported subtypes. This method can be used to implement encoding and decoding over algebraic types or sealed class hierarchies which may require different codecs for each subtype.
    This method is equivalent to dispatchStable("type", type, codec).
    Warning: This method is unsound. Care must be taken that the codecs returned by codec actually accept the correct subtype, and not an incidental subtype thereof. Heap pollution may occur when using this method unless the programmer checks that the correct types are inferred or specified.
    
    Implementation Requirements:
    
    The default implementation calls partialDispatch(String, Function, Function) with the type key "type".
    
    Type Parameters:
    
    E - The polymorphic object type.
    
    Parameters:
    
    type - A function that extracts the type key from the a polymorphic value.
    
    codec - A function that produces a codec for a subtype corresponding to the provided type key.
    
    Returns:
    
    A codec that operates on the polymorphic object type.
    
    See Also:
    
    dispatchStable(Function, Function)
  - partialDispatch
```
default <E> Codec<E> partialDispatch(String typeKey,
                                     (? super E) -> ? extends DataResult<? extends A> type,
                                     (? super A) -> ? extends DataResult<? extends Codec<? extends E>> codec)
```
    Returns a Codec that uses a type key extracted using this codec to polymorphically dispatch against a partial set of supported subtypes. This method can be used to implement partial encoding and decoding over algebraic types or sealed class hierarchies which may require different codecs for each subtype.
    Warning: This method is unsound. Care must be taken that the codecs returned by codec actually accept the correct subtype, and not an incidental subtype thereof. Heap pollution may occur when using this method unless the programmer checks that the correct types are inferred or specified.
    
    Implementation Requirements:
    
    The default implementation returns a codec generated from a KeyDispatchCodec.
    
    Type Parameters:
    
    E - The polymorphic object type.
    
    Parameters:
    
    typeKey - The field in the record that the serialized type key is stored under.
    
    type - A partial function that extracts the type key from the a polymorphic value.
    
    codec - A function that produces a codec for a subtype corresponding to the provided type key.
    
    Returns:
    
    A codec that operates on the polymorphic object type.
    
    See Also:
    
    dispatch(String, Function, Function)
  - dispatchMap
```
default <E> MapCodec<E> dispatchMap((? super E) -> ? extends A type,
                                    (? super A) -> ? extends Codec<? extends E> codec)
```
    Returns a MapCodec that uses a default type key extracted using this codec to polymorphically dispatch against a complete set of supported subtypes. This method can be used to implement encoding and decoding over algebraic types or sealed class hierarchies which may require different codecs for each subtype.
    This method is equivalent to dispatchMap("type", type, codec).
    Warning: This method is unsound. Care must be taken that the codecs returned by codec actually accept the correct subtype, and not an incidental subtype thereof. Heap pollution may occur when using this method unless the programmer checks that the correct types are inferred or specified.
    
    Implementation Requirements:
    
    The default implementation calls dispatchMap(String, Function, Function) with the type key "type".
    
    Type Parameters:
    
    E - The polymorphic object type.
    
    Parameters:
    
    type - A function that extracts the type key from the a polymorphic value.
    
    codec - A function that produces a codec for a subtype corresponding to the provided type key.
    
    Returns:
    
    A codec that operates on the polymorphic object type.
    
    See Also:
    
    dispatchStable(Function, Function)
  - dispatchMap
```
default <E> MapCodec<E> dispatchMap(String typeKey,
                                    (? super E) -> ? extends A type,
                                    (? super A) -> ? extends Codec<? extends E> codec)
```
    Returns a MapCodec that uses a type key extracted using this codec to polymorphically dispatch against a complete set of supported subtypes. This method can be used to implement encoding and decoding over algebraic types or sealed class hierarchies which may require different codecs for each subtype.
    Warning: This method is unsound. Care must be taken that the codecs returned by codec actually accept the correct subtype, and not an incidental subtype thereof. Heap pollution may occur when using this method unless the programmer checks that the correct types are inferred or specified.
    
    Implementation Requirements:
    
    The default implementation returns a new KeyDispatchCodec with the type and codec functions always returning a success.
    
    Type Parameters:
    
    E - The polymorphic object type.
    
    Parameters:
    
    typeKey - The field in the record that the serialized type key is stored under.
    
    type - A function that extracts the type key from the a polymorphic value.
    
    codec - A function that produces a codec for a subtype corresponding to the provided type key.
    
    Returns:
    
    A codec that operates on the polymorphic object type.
    
    See Also:
    
    KeyDispatchCodec
  - checkRange
```
static <N extends Number & Comparable<N>> (N) -> DataResult<N> checkRange(N minInclusive,
                                                                          N maxInclusive)
```
  - intRange
```
static Codec<Integer> intRange(int minInclusive,
                               int maxInclusive)
```
  - floatRange
```
static Codec<Float> floatRange(float minInclusive,
                               float maxInclusive)
```
  - doubleRange
```
static Codec<Double> doubleRange(double minInclusive,
                                 double maxInclusive)
```

Interface Codec<A>

Nested Class Summary

Nested classes/interfaces inherited from interface com.mojang.serialization.Decoder

Field Summary

Method Summary

Methods inherited from interface com.mojang.serialization.Encoder

Methods inherited from interface com.mojang.serialization.Decoder

Field Detail

BOOL

BYTE

SHORT

INT

LONG

FLOAT

DOUBLE

STRING

BYTE_BUFFER

INT_STREAM

LONG_STREAM

PASSTHROUGH

EMPTY

Method Detail

withLifecycle

stable

deprecated

of

of

of

of

pair

either

mapPair

mapEither

list

compoundList

simpleMap

unboundedMap

optionalField

listOf

xmap

comapFlatMap

flatComapMap

flatXmap

fieldOf

optionalFieldOf

optionalFieldOf

optionalFieldOf

optionalFieldOf

mapResult

orElse

orElse

orElseGet

orElseGet

orElse

orElseGet

promotePartial

unit

unit

dispatch

dispatch

dispatchStable

partialDispatch

dispatchMap

dispatchMap

checkRange

intRange

floatRange

doubleRange