icybear/fabric-carpet
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

semi-auto cleanup

Browse Source
This commit is contained in:
gnembon committed 2023-02-04 13:26:21 +01:00
1 parent cad80f82c6
commit 8f61271606
99 files changed
+11463 -8007
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/main/java/carpet/script/annotation/Locator.java
+56 -26
View File
@@ -37,7 +37,7 @@ public interface Locator
@Documented
@Retention(RUNTIME)
@Target({ PARAMETER, TYPE_USE })
public @interface Block
@interface Block
{
/**
* <p>Whether or not should the locator accept a single {@link String} as the parameter and let parsing to {@link BlockValue}.</p>
@@ -66,7 +66,7 @@ public interface Locator
@Documented
@Retention(RUNTIME)
@Target({ PARAMETER, TYPE_USE })
public @interface Vec3d
@interface Vec3d
{
/**
* <p>Whether or not should the {@link Vector3Argument} locator accept an optional direction aside from the
@@ -94,7 +94,7 @@ public interface Locator
@Documented
@Retention(RUNTIME)
@Target({ PARAMETER, TYPE_USE })
public @interface Function
@interface Function
{
/**
* <p>Whether this Locator should allow no function to be passed.</p> <p>This is not compatible with {@link FunctionValue} type, since a
@@ -115,18 +115,27 @@ public interface Locator
*
* <p>Not part of the public API, just that interfaces must have all members public</p>
*/
static final class Locators
final class Locators
{
private Locators() {}
private Locators()
{
super();
}
static <R> ValueConverter<R> fromAnnotatedType(AnnotatedType annoType, Class<R> type)
static <R> ValueConverter<R> fromAnnotatedType(final AnnotatedType annoType, final Class<R> type)
{
if (annoType.isAnnotationPresent(Block.class))
return new BlockLocator<R>(annoType.getAnnotation(Block.class), type);
{
return new BlockLocator<>(annoType.getAnnotation(Block.class), type);
}
if (annoType.isAnnotationPresent(Function.class))
return new FunctionLocator<R>(annoType.getAnnotation(Function.class), type);
{
return new FunctionLocator<>(annoType.getAnnotation(Function.class), type);
}
if (annoType.isAnnotationPresent(Vec3d.class))
return new Vec3dLocator<R>(annoType.getAnnotation(Vec3d.class), type);
{
return new Vec3dLocator<>(annoType.getAnnotation(Vec3d.class), type);
}
throw new IllegalStateException("Locator#fromAnnotatedType got called with an incompatible AnnotatedType");
}
@@ -137,28 +146,42 @@ public interface Locator
private final boolean anyString;
private final boolean optional;
public BlockLocator(Block annotation, Class<R> type)
public BlockLocator(final Block annotation, final Class<R> type)
{
super();
this.acceptString = annotation.acceptString();
this.anyString = annotation.anyString();
this.optional = annotation.optional();
if (type != BlockArgument.class && (anyString || optional))
{
throw new IllegalArgumentException("Can only use anyString or optional parameters of Locator.Block if targeting a BlockArgument");
}
this.returnFunction = getReturnFunction(type);
if (returnFunction == null)
{
throw new IllegalArgumentException("Locator.Block can only be used against BlockArgument, BlockValue, BlockPos or BlockState types!");
}
}
@SuppressWarnings("unchecked")
private static <R> java.util.function.Function<BlockArgument, R> getReturnFunction(Class<R> type) {
private static <R> java.util.function.Function<BlockArgument, R> getReturnFunction(final Class<R> type)
{
if (type == BlockArgument.class)
{
return r -> (R) r;
}
if (type == BlockValue.class)
{
return r -> (R) r.block;
}
if (type == BlockPos.class)
{
return r -> (R) r.block.getPos();
}
if (type == BlockState.class)
{
return r -> (R) r.block.getBlockState();
}
return null;
}
@@ -169,9 +192,9 @@ public interface Locator
}
@Override
public R checkAndConvert(Iterator<Value> valueIterator, Context context, Context.Type theLazyT)
public R checkAndConvert(final Iterator<Value> valueIterator, final Context context, final Context.Type theLazyT)
{
BlockArgument locator = BlockArgument.findIn((CarpetContext) context, valueIterator, 0, acceptString, optional, anyString);
final BlockArgument locator = BlockArgument.findIn((CarpetContext) context, valueIterator, 0, acceptString, optional, anyString);
return returnFunction.apply(locator);
}
}
@@ -182,15 +205,19 @@ public interface Locator
private final boolean optionalEntity;
private final boolean returnVec3d;
public Vec3dLocator(Vec3d annotation, Class<R> type)
public Vec3dLocator(final Vec3d annotation, final Class<R> type)
{
this.optionalDirection = annotation.optionalDirection();
this.optionalEntity = annotation.optionalEntity();
this.returnVec3d = type == net.minecraft.world.phys.Vec3.class; // Because of the locator
if (returnVec3d && optionalDirection)
{
throw new IllegalArgumentException("optionalDirection Locator.Vec3d cannot be used for Vec3d type, use Vector3Argument instead");
}
if (!returnVec3d && type != Vector3Argument.class)
{
throw new IllegalArgumentException("Locator.Vec3d can only be used in Vector3Argument or Vec3d types");
}
}
@Override
@@ -200,11 +227,10 @@ public interface Locator
}
@Override
public R checkAndConvert(Iterator<Value> valueIterator, Context context, Context.Type theLazyT)
public R checkAndConvert(final Iterator<Value> valueIterator, final Context context, final Context.Type theLazyT)
{
Vector3Argument locator = Vector3Argument.findIn(valueIterator, 0, optionalDirection, optionalEntity);
@SuppressWarnings("unchecked")
R ret = (R) (returnVec3d ? locator.vec : locator);
final Vector3Argument locator = Vector3Argument.findIn(valueIterator, 0, optionalDirection, optionalEntity);
@SuppressWarnings("unchecked") final R ret = (R) (returnVec3d ? locator.vec : locator);
return ret;
}
}
@@ -215,24 +241,28 @@ public interface Locator
private final boolean allowNone;
private final boolean checkArgs;
FunctionLocator(Function annotation, Class<R> type)
FunctionLocator(final Function annotation, final Class<R> type)
{
super();
this.returnFunctionValue = type == FunctionValue.class;
if (!returnFunctionValue && type != FunctionArgument.class)
{
throw new IllegalArgumentException("Params annotated with Locator.Function must be of either FunctionArgument or FunctionValue type");
}
this.allowNone = annotation.allowNone();
this.checkArgs = annotation.checkArgs();
if (returnFunctionValue && allowNone)
{
throw new IllegalArgumentException("Cannot use allowNone of Locator.Function in FunctionValue types, use FunctionArgument");
}
}
@Override
public R checkAndConvert(Iterator<Value> valueIterator, Context context, Context.Type theLazyT)
public R checkAndConvert(final Iterator<Value> valueIterator, final Context context, final Context.Type theLazyT)
{
Module module = context.host.main;
FunctionArgument locator = FunctionArgument.findIn(context, module, Lists.newArrayList(valueIterator), 0, allowNone, checkArgs);
@SuppressWarnings("unchecked")
R ret = (R) (returnFunctionValue ? locator.function : locator);
final Module module = context.host.main;
final FunctionArgument locator = FunctionArgument.findIn(context, module, Lists.newArrayList(valueIterator), 0, allowNone, checkArgs);
@SuppressWarnings("unchecked") final R ret = (R) (returnFunctionValue ? locator.function : locator);
return ret;
}
@@ -243,10 +273,10 @@ public interface Locator
}
}
private static abstract class AbstractLocator<R> implements ValueConverter<R>, Locator
private abstract static class AbstractLocator<R> implements ValueConverter<R>, Locator
{
@Override
public R convert(Value value)
public R convert(final Value value)
{
throw new UnsupportedOperationException("Cannot call a locator in a parameter that doesn't contain a context!");
}