com.mojang.datafixers.types

Class Type<A>

java.lang.Object

com.mojang.datafixers.types.Type<A>

All Implemented Interfaces:

Type.Mu<A>

Direct Known Subclasses:

Check.CheckType, CompoundList.CompoundListType, Const.PrimitiveType, EmptyPart, EmptyPartPassthrough, Func, Hook.HookType, List.ListType, Named.NamedType, Product.ProductType, RecursivePoint.RecursivePointType, Sum.SumType, Tag.TagType, TaggedChoice.TaggedChoiceType

public abstract class Type<A>
extends Object

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Type.Continue
static class	Type.FieldNotFoundException
static class	Type.Mu
static class	Type.TypeError
static interface	Type.TypeMatcher<FT,FR>

Constructor Summary

Constructors

Constructor and Description
Type()

Method Summary

Modifier and Type	Method and Description
RewriteResult<A,?>	all(TypeRewriteRule rule, boolean recurse, boolean checkIndex) gmapT run rule on all direct children and combine results
protected abstract Codec<A>	buildCodec()
abstract TypeTemplate	buildTemplate()
Codec<A>	codec()
boolean	equals(Object o)
abstract boolean	equals(Object o, boolean ignoreRecursionPoints, boolean checkIndex)
Optional<RewriteResult<A,?>>	everywhere(TypeRewriteRule rule, PointFreeRule optimizationRule, boolean recurse, boolean checkIndex)
Optional<Type<?>>	findCheckedType(int index)
Optional<TaggedChoice.TaggedChoiceType<?>>	findChoiceType(String name, int index)
OpticFinder<A>	finder()
OpticFinder<?>	findField(String name)
Type<?>	findFieldType(String name)
Optional<Type<?>>	findFieldTypeOpt(String name)
<FT,FR> (TypedOptic<A,?,FT,FR>|Type.FieldNotFoundException)	findType(Type<FT> type, Type<FR> resultType, Type.TypeMatcher<FT,FR> matcher, boolean recurse)
<FT,FR> (TypedOptic<A,?,FT,FR>|Type.FieldNotFoundException)	findTypeCached(Type<FT> type, Type<FR> resultType, Type.TypeMatcher<FT,FR> matcher, boolean recurse)
<FT,FR> (TypedOptic<A,?,FT,FR>|Type.FieldNotFoundException)	findTypeInChildren(Type<FT> type, Type<FR> resultType, Type.TypeMatcher<FT,FR> matcher, boolean recurse)
<FT,FR> Type<?>	getSetType(OpticFinder<FT> optic, Type<FR> newType)
<B> Optional<A>	ifSame(Type<B> type, B value)
<B> Optional<RewriteResult<A,?>>	ifSame(Type<B> type, RewriteResult<B,?> value)
<B> Optional<A>	ifSame(Typed<B> value)
Optional<RewriteResult<A,?>>	one(TypeRewriteRule rule) run rule on exactly one child
static <S,T,A,B> RewriteResult<S,T>	opticView(Type<S> type, RewriteResult<A,B> view, TypedOptic<S,T,A,B> optic)
Optional<A>	point(DynamicOps<?> ops) populate with the default value, if possible only initializes empty things
Optional<Typed<A>>	pointTyped(DynamicOps<?> ops)
<T> DataResult<(A,Dynamic<T>)>	read(Dynamic<T> input)
<T> DataResult<(Optional<?>,T)>	read(DynamicOps<T> ops, TypeRewriteRule rule, PointFreeRule fRule, T input)
<T> DataResult<T>	readAndWrite(DynamicOps<T> ops, Type<?> expectedType, TypeRewriteRule rule, PointFreeRule fRule, T input)
<T> DataResult<(Typed<A>,T)>	readTyped(Dynamic<T> input)
<T> DataResult<(Typed<A>,T)>	readTyped(DynamicOps<T> ops, T input)
Optional<RewriteResult<A,?>>	rewrite(TypeRewriteRule rule, PointFreeRule fRule)
RewriteResult<A,?>	rewriteOrNop(TypeRewriteRule rule)
TypeTemplate	template()
static <A> Type<A>	unbox(Type.Mu<A> box)
Type<?>	updateMu(RecursiveTypeFamily newFamily)
<T> DataResult<T>	write(DynamicOps<T> ops, A value)
<T> DataResult<Dynamic<T>>	writeDynamic(DynamicOps<T> ops, A value)

Methods inherited from class java.lang.Object

clone, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Type

public Type()

Method Detail

unbox

public static <A> Type<A> unbox(Type.Mu<A> box)

rewriteOrNop

public RewriteResult<A,?> rewriteOrNop(TypeRewriteRule rule)

opticView

public static <S,T,A,B> RewriteResult<S,T> opticView(Type<S> type,
                                                     RewriteResult<A,B> view,
                                                     TypedOptic<S,T,A,B> optic)

all

public RewriteResult<A,?> all(TypeRewriteRule rule,
                              boolean recurse,
                              boolean checkIndex)

gmapT run rule on all direct children and combine results

one

public Optional<RewriteResult<A,?>> one(TypeRewriteRule rule)

run rule on exactly one child

everywhere

public Optional<RewriteResult<A,?>> everywhere(TypeRewriteRule rule,
                                               PointFreeRule optimizationRule,
                                               boolean recurse,
                                               boolean checkIndex)

updateMu

public Type<?> updateMu(RecursiveTypeFamily newFamily)

template

public TypeTemplate template()

buildTemplate

public abstract TypeTemplate buildTemplate()

findChoiceType

public Optional<TaggedChoice.TaggedChoiceType<?>> findChoiceType(String name,
                                                                 int index)

findCheckedType

public Optional<Type<?>> findCheckedType(int index)

read

public final <T> DataResult<(A,Dynamic<T>)> read(Dynamic<T> input)

codec

public final Codec<A> codec()

buildCodec

protected abstract Codec<A> buildCodec()

write

public final <T> DataResult<T> write(DynamicOps<T> ops,
                                     A value)

writeDynamic

public final <T> DataResult<Dynamic<T>> writeDynamic(DynamicOps<T> ops,
                                                     A value)

readTyped

public <T> DataResult<(Typed<A>,T)> readTyped(Dynamic<T> input)

readTyped

public <T> DataResult<(Typed<A>,T)> readTyped(DynamicOps<T> ops,
                                              T input)

read

public <T> DataResult<(Optional<?>,T)> read(DynamicOps<T> ops,
                                            TypeRewriteRule rule,
                                            PointFreeRule fRule,
                                            T input)

readAndWrite

public <T> DataResult<T> readAndWrite(DynamicOps<T> ops,
                                      Type<?> expectedType,
                                      TypeRewriteRule rule,
                                      PointFreeRule fRule,
                                      T input)

rewrite

public Optional<RewriteResult<A,?>> rewrite(TypeRewriteRule rule,
                                            PointFreeRule fRule)

getSetType

public <FT,FR> Type<?> getSetType(OpticFinder<FT> optic,
                                  Type<FR> newType)

findFieldTypeOpt

public Optional<Type<?>> findFieldTypeOpt(String name)

findFieldType

public Type<?> findFieldType(String name)

findField

public OpticFinder<?> findField(String name)

point

public Optional<A> point(DynamicOps<?> ops)

populate with the default value, if possible only initializes empty things

pointTyped

public Optional<Typed<A>> pointTyped(DynamicOps<?> ops)

findTypeCached

public <FT,FR> (TypedOptic<A,?,FT,FR>|Type.FieldNotFoundException) findTypeCached(Type<FT> type,
                                                                                  Type<FR> resultType,
                                                                                  Type.TypeMatcher<FT,FR> matcher,
                                                                                  boolean recurse)

findType

public <FT,FR> (TypedOptic<A,?,FT,FR>|Type.FieldNotFoundException) findType(Type<FT> type,
                                                                            Type<FR> resultType,
                                                                            Type.TypeMatcher<FT,FR> matcher,
                                                                            boolean recurse)

findTypeInChildren

public <FT,FR> (TypedOptic<A,?,FT,FR>|Type.FieldNotFoundException) findTypeInChildren(Type<FT> type,
                                                                                      Type<FR> resultType,
                                                                                      Type.TypeMatcher<FT,FR> matcher,
                                                                                      boolean recurse)

finder

public OpticFinder<A> finder()

ifSame

public <B> Optional<A> ifSame(Typed<B> value)

ifSame

public <B> Optional<A> ifSame(Type<B> type,
                              B value)

ifSame

public <B> Optional<RewriteResult<A,?>> ifSame(Type<B> type,
                                               RewriteResult<B,?> value)

equals

public final boolean equals(Object o)

Overrides:

equals in class Object

equals

public abstract boolean equals(Object o,
                               boolean ignoreRecursionPoints,
                               boolean checkIndex)